arb_direct_state_access: Added tests for glGetCompressedTextureImage.

6 files changed, 713 insertions, 2 deletions

diff --git a/tests/all.py b/tests/all.py
index e6b46c86c..83f26edd1 100644
--- a/tests/all.py
+++ b/tests/all.py
@@ -4323,7 +4323,8 @@ spec['ARB_direct_state_access']['gettextureimage-formats'] = PiglitGLTest('arb_d
 spec['ARB_direct_state_access']['gettextureimage-luminance'] = PiglitGLTest('arb_direct_state_access-gettextureimage-luminance', run_concurrent=True)
 spec['ARB_direct_state_access']['gettextureimage-simple'] = PiglitGLTest('arb_direct_state_access-gettextureimage-simple', run_concurrent=True)
 spec['ARB_direct_state_access']['gettextureimage-targets'] = PiglitGLTest('arb_direct_state_access-gettextureimage-targets', run_concurrent=True)
-
+spec['ARB_direct_state_access']['compressedtextureimage'] = PiglitGLTest('arb_direct_state_access-compressedtextureimage GL_COMPRESSED_RGBA_FXT1_3DFX', run_concurrent=True)
+spec['ARB_direct_state_access']['getcompressedtextureimage'] = PiglitGLTest('arb_direct_state_access-getcompressedtextureimage', run_concurrent=True)
 
 profile.tests['hiz'] = hiz
 profile.tests['fast_color_clear'] = fast_color_clear
diff --git a/tests/spec/arb_direct_state_access/CMakeLists.gl.txt b/tests/spec/arb_direct_state_access/CMakeLists.gl.txt
index 3d8ea4293..dfb1255d2 100644
--- a/tests/spec/arb_direct_state_access/CMakeLists.gl.txt
+++ b/tests/spec/arb_direct_state_access/CMakeLists.gl.txt
@@ -23,4 +23,6 @@ piglit_add_executable (arb_direct_state_access-gettextureimage-formats gettextur
 piglit_add_executable (arb_direct_state_access-gettextureimage-luminance gettextureimage-luminance.c)
 piglit_add_executable (arb_direct_state_access-gettextureimage-simple gettextureimage-simple.c)
 piglit_add_executable (arb_direct_state_access-gettextureimage-targets gettextureimage-targets.c)
+piglit_add_executable (arb_direct_state_access-compressedtextureimage compressedtextureimage.c)
+piglit_add_executable (arb_direct_state_access-getcompressedtextureimage getcompressedtextureimage.c)
 # vim: ft=cmake:
diff --git a/tests/spec/arb_direct_state_access/compressedtextureimage.c b/tests/spec/arb_direct_state_access/compressedtextureimage.c
new file mode 100644
index 000000000..d8875b6a7
--- /dev/null
+++ b/tests/spec/arb_direct_state_access/compressedtextureimage.c
@@ -0,0 +1,288 @@
+/*
+ * Copyright © 2011 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.
+ */
+
+/** @file compressedtextureimage.c
+ *
+ * Tests that fetching and uploading compressed texture data works
+ * correctly.
+ *
+ * The other compressed texture tests are about decoding of data that
+ * was uploaded from uncompressed, while this tries a round-trip after
+ * the initial upload, testing glGetCompressedTexImage() and
+ * glCompressedTexImage2D().
+ *
+ * Adapted for testing glGetCompressedTextureImage in ARB_direct_state_access
+ * by Laura Ekstrand <laura@jlekstrand.net>, November 2014.
+ */
+
+#include "piglit-util-gl.h"
+
+#define SIZE 128
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+	config.supports_gl_compat_version = 10;
+
+	config.window_width = (SIZE*2)+60;
+	config.window_height = SIZE+20;
+	config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+struct format {
+	const char *name;
+	GLenum token;
+	const char **extension;
+};
+
+static struct format *format;
+
+const char *FXT1[] = {
+	"GL_3DFX_texture_compression_FXT1",
+	NULL
+};
+
+const char *S3TC[] = {
+	"GL_EXT_texture_compression_s3tc",
+	NULL
+};
+
+const char *S3TC_srgb[] = {
+	"GL_EXT_texture_compression_s3tc",
+	"GL_EXT_texture_sRGB",
+	NULL
+};
+
+const char *RGTC[] = {
+	"GL_ARB_texture_compression_rgtc",
+	NULL
+};
+
+const char *RGTC_signed[] = {
+	"GL_ARB_texture_compression_rgtc",
+	"GL_EXT_texture_snorm",
+	NULL
+};
+
+const char *BPTC[] = {
+	"GL_ARB_texture_compression_bptc",
+	NULL
+};
+
+#define FORMAT(t, ext) { #t, t, ext }
+static struct format formats[] = {
+	FORMAT(GL_COMPRESSED_RGB_FXT1_3DFX, FXT1),
+	FORMAT(GL_COMPRESSED_RGBA_FXT1_3DFX, FXT1),
+
+	FORMAT(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, S3TC),
+	FORMAT(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, S3TC),
+	FORMAT(GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, S3TC),
+	FORMAT(GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, S3TC),
+
+	FORMAT(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT, S3TC_srgb),
+	FORMAT(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, S3TC_srgb),
+	FORMAT(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, S3TC_srgb),
+	FORMAT(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, S3TC_srgb),
+
+	FORMAT(GL_COMPRESSED_RGBA_BPTC_UNORM, BPTC),
+	FORMAT(GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM, BPTC),
+	FORMAT(GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT, BPTC),
+	FORMAT(GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT, BPTC),
+
+	FORMAT(GL_COMPRESSED_RED_RGTC1_EXT, RGTC),
+	FORMAT(GL_COMPRESSED_SIGNED_RED_RGTC1_EXT, RGTC_signed),
+	FORMAT(GL_COMPRESSED_RED_GREEN_RGTC2_EXT, RGTC),
+	FORMAT(GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT, RGTC_signed),
+};
+
+static void
+display_mipmaps(int x, int y)
+{
+	int i;
+
+	glEnable(GL_TEXTURE_2D);
+
+	/* Disply all the mipmap levels */
+	for (i = SIZE; i > 0; i /= 2) {
+		piglit_draw_rect_tex(x, y, i, i,
+				     0, 0, 1, 1);
+
+		x += i + 5;
+	}
+}
+
+static GLboolean
+check_resulting_mipmaps(int x, int y)
+{
+	GLboolean pass = GL_TRUE;
+	int size;
+	float red[4] =   {1.0, 0.0, 0.0, 1.0};
+	float green[4] = {0.0, 1.0, 0.0, 1.0};
+	float blue[4] =  {0.0, 0.0, 1.0, 1.0};
+	float white[4] = {1.0, 1.0, 1.0, 1.0};
+
+	/* for r, rg textures, overwrite what the expected colors are. */
+	if (format->token == GL_COMPRESSED_RED_RGTC1_EXT ||
+	    format->token == GL_COMPRESSED_SIGNED_RED_RGTC1_EXT) {
+		green[1] = 0;
+		blue[2] = 0;
+		white[1] = 0;
+		white[2] = 0;
+	}
+	if (format->token == GL_COMPRESSED_RED_GREEN_RGTC2_EXT ||
+	    format->token == GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT) {
+		blue[2] = 0;
+		white[2] = 0;
+	}
+
+	for (size = SIZE; size > 0; size /= 2) {
+		if (size == 4)
+			pass = pass && piglit_probe_pixel_rgb(x + 2, y + 2,
+							      red);
+		else if (size == 2)
+			pass = pass && piglit_probe_pixel_rgb(x + 1, y + 1,
+							      green);
+		else if (size == 1)
+			pass = pass && piglit_probe_pixel_rgb(x, y,
+							      blue);
+		else {
+			pass = pass && piglit_probe_pixel_rgb(x + size / 4,
+							      y + size / 4,
+							      red);
+			pass = pass && piglit_probe_pixel_rgb(x + size * 3 / 4,
+							      y + size / 4,
+							      green);
+			pass = pass && piglit_probe_pixel_rgb(x + size / 4,
+							      y + size * 3 / 4,
+							      blue);
+			pass = pass && piglit_probe_pixel_rgb(x + size * 3 / 4,
+							      y + size * 3 / 4,
+							      white);
+		}
+		x += size + 5;
+	}
+
+	return pass;
+}
+
+enum piglit_result
+piglit_display(void)
+{
+	GLuint tex, tex_src;
+	bool pass;
+	int level;
+	unsigned bw, bh, bs;
+
+	piglit_get_compressed_block_size(format->token, &bw, &bh, &bs);
+	glClearColor(0.5, 0.5, 0.5, 0.5);
+	glClear(GL_COLOR_BUFFER_BIT);
+
+	tex_src = piglit_rgbw_texture(format->token, SIZE, SIZE,
+				      GL_TRUE, GL_FALSE,
+				      GL_UNSIGNED_NORMALIZED);
+	glCreateTextures(GL_TEXTURE_2D, 1, &tex);
+
+	for (level = 0; (SIZE >> level) > 0; level++) {
+		int w, h;
+		int expected_size, size;
+		void *compressed;
+
+		w = SIZE >> level;
+		h = SIZE >> level;
+		expected_size = piglit_compressed_image_size(format->token, w, h);
+
+		glBindTexture(GL_TEXTURE_2D, tex_src);
+		glGetTexLevelParameteriv(GL_TEXTURE_2D, level,
+					 GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
+					 &size);
+
+		if (size != expected_size) {
+			fprintf(stderr, "Format %s level %d (%dx%d) size %d "
+				"doesn't match expected size %d\n",
+				format->name, level, w, h, size, expected_size);
+			piglit_report_result(PIGLIT_FAIL);
+		}
+
+		compressed = malloc(size);
+
+		glGetCompressedTextureImage(tex_src, level, size, compressed);
+
+		glBindTexture(GL_TEXTURE_2D, tex);
+		glCompressedTexImage2D(GL_TEXTURE_2D, level, format->token,
+				       w, h, 0, size, compressed);
+		if (!piglit_check_gl_error(GL_NO_ERROR))
+			piglit_report_result(PIGLIT_FAIL);
+
+		free(compressed);
+	}
+
+	glDeleteTextures(1, &tex_src);
+	glBindTextureUnit(tex, 0);
+
+	display_mipmaps(10, 10);
+	pass = check_resulting_mipmaps(10, 10);
+
+	piglit_present_results();
+
+	return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+static void
+usage(int argc, char **argv)
+{
+	int i;
+
+	fprintf(stderr, "Usage: %s <format>\n", argv[0]);
+	fprintf(stderr, "format is one of:\n");
+	for (i = 0; i < ARRAY_SIZE(formats); i++) {
+		fprintf(stderr, "  %s\n", formats[i].name);
+	}
+	exit(1);
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+	int i;
+	piglit_require_extension("GL_ARB_direct_state_access");
+
+	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+
+	if (argc != 2)
+		usage(argc, argv);
+
+	format = NULL;
+
+	for (i = 0; i < ARRAY_SIZE(formats); i++) {
+		if (strcmp(formats[i].name, argv[1]) == 0) {
+			format = &formats[i];
+			break;
+		}
+	}
+
+	if (!format)
+		usage(argc, argv);
+
+	for (i = 0; format->extension[i]; i++)
+		piglit_require_extension(format->extension[i]);
+}
diff --git a/tests/spec/arb_direct_state_access/getcompressedtextureimage.c b/tests/spec/arb_direct_state_access/getcompressedtextureimage.c
new file mode 100644
index 000000000..9537dca9b
--- /dev/null
+++ b/tests/spec/arb_direct_state_access/getcompressedtextureimage.c
@@ -0,0 +1,419 @@
+/*
+ * Copyright © 2012 Marek Olšák <maraeo@gmail.com>
+ * 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.
+ */
+
+/**
+ * @file getcompressedtextureimage-targets.c
+ *
+ * Adapted for testing glGetCompressedTextureImage in ARB_direct_state_access
+ * by Laura Ekstrand <laura@jlekstrand.net>, November 2014.
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+	config.window_width = 216;
+	config.supports_gl_compat_version = 10;
+
+	config.window_visual = PIGLIT_GL_VISUAL_RGBA |
+			       PIGLIT_GL_VISUAL_DOUBLE;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+#define IMAGE_WIDTH 32
+#define IMAGE_HEIGHT 32
+#define IMAGE_SIZE (IMAGE_WIDTH * IMAGE_HEIGHT * 4)
+#define DISPLAY_GAP 4
+
+static void
+show_image(GLubyte *data, int num_layers, const char *title)
+{
+	GLuint name;
+	int i;
+	char junk[50];
+
+	if (!piglit_automatic) {
+		/* Create the texture handle. */
+		glCreateTextures(GL_TEXTURE_2D, 1, &name);
+		glTextureStorage2D(name, 1, GL_RGBA8, IMAGE_WIDTH,
+			IMAGE_HEIGHT);
+		glTextureParameteri(name, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTextureParameteri(name, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+		glEnable(GL_TEXTURE_2D);
+		glBindTextureUnit(0, name);
+
+		/* Draw the layers, separated by some space */
+		glClear(GL_COLOR_BUFFER_BIT);
+		for (i = 0; i < num_layers; ++i) {
+			int x = (IMAGE_WIDTH + DISPLAY_GAP) * (i % 6);
+			int y = (IMAGE_HEIGHT + DISPLAY_GAP) * (i / 6);
+			glTextureSubImage2D(name, 0, 0, 0,
+					    IMAGE_WIDTH, IMAGE_HEIGHT,
+					    GL_RGBA, GL_UNSIGNED_BYTE,
+					    data + i * IMAGE_SIZE);
+			piglit_draw_rect_tex(x, y, IMAGE_WIDTH, IMAGE_HEIGHT,
+					     0, 0, 1, 1);
+		}
+
+		/* Make the title. */
+		printf("****** %s ******\n", title);
+
+		piglit_present_results();
+
+		/* Pause. */
+		printf("Enter any char to continue.\n>>>>>>");
+		scanf("%s", junk);
+		printf("\n");
+
+		glDeleteTextures(1, &name);
+	}
+}
+
+static GLubyte *
+make_layer_data(int num_layers)
+{
+	int z;
+	GLubyte *layer_data =
+		malloc(num_layers * IMAGE_SIZE * sizeof(GLubyte));
+
+	for (z = 0; z < num_layers; z++) {
+		GLubyte *data = piglit_rgbw_image_ubyte(IMAGE_WIDTH,
+							IMAGE_HEIGHT, true);
+		memcpy(layer_data + IMAGE_SIZE * z, data, IMAGE_SIZE);
+	}
+
+	/* Show the first layer of the completed layer data. */
+	show_image(layer_data, num_layers, "Test Data");
+
+	return layer_data;
+}
+
+static bool
+compare_layer(int layer, int num_elements, int tolerance,
+			  GLubyte *data, GLubyte *expected)
+{
+	int i;
+
+	for (i = 0; i < num_elements; ++i) {
+		if (fabs((int)data[i] - (int)expected[i]) > tolerance) {
+			printf("GetCompressedTextureImage() returns incorrect"
+			       " data in byte %i for layer %i\n",
+			       i, layer);
+			printf("    corresponding to (%i,%i), channel %i\n",
+			       (i / 4) / IMAGE_WIDTH, (i / 4) % IMAGE_HEIGHT,
+				i % 4);
+			printf("    expected: %i\n", expected[i]);
+			printf("    got: %i\n", data[i]);
+			return false;
+		}
+	}
+	return true;
+}
+
+static enum piglit_result
+getTexImage(bool doPBO, GLenum target, GLubyte *data,
+	    GLenum internalformat, int tolerance)
+{
+	int i;
+	int num_layers=1, num_faces=1, layer_size;
+	GLubyte *data2 = NULL;
+	GLubyte *dataGet;
+	GLuint packPBO;
+	bool pass = true;
+	GLuint name;
+	GLint compressed;
+	GLint comp_size;
+
+	/* Upload the data. */
+	switch (target) {
+
+	/* These are all targets that can be compressed according to
+	 * _mesa_target_can_be_compressed */
+
+	case GL_TEXTURE_2D:
+		glCreateTextures(target, 1, &name);
+		glTextureStorage2D(name, 1, internalformat, IMAGE_WIDTH,
+				   IMAGE_HEIGHT);
+		glTextureSubImage2D(name, 0, 0, 0, IMAGE_WIDTH, IMAGE_HEIGHT,
+				    GL_RGBA, GL_UNSIGNED_BYTE, data);
+		layer_size = IMAGE_SIZE;
+		break;
+
+	case GL_TEXTURE_CUBE_MAP:
+		num_faces = 6;
+		glCreateTextures(target, 1, &name);
+		/* This is invalid. You must use 2D storage call for cube. */
+		glTextureStorage3D(name, 1, internalformat,
+				   IMAGE_WIDTH, IMAGE_HEIGHT, num_faces);
+		pass &= piglit_check_gl_error(GL_INVALID_ENUM);
+		glTextureStorage2D(name, 1, internalformat,
+				   IMAGE_WIDTH, IMAGE_HEIGHT);
+		/* This is legal. */
+		glTextureSubImage3D(name, 0, 0, 0, 0, IMAGE_WIDTH,
+				    IMAGE_HEIGHT, num_faces, GL_RGBA,
+				    GL_UNSIGNED_BYTE, data);
+		layer_size = IMAGE_SIZE;
+		break;
+
+	case GL_TEXTURE_2D_ARRAY:
+		num_layers = 7; /* Fall through. */
+	case GL_TEXTURE_CUBE_MAP_ARRAY:
+		num_layers = 6 * 3;
+		glCreateTextures(target, 1, &name);
+		glTextureStorage3D(name, 1, internalformat, IMAGE_WIDTH,
+				   IMAGE_HEIGHT, num_layers);
+		glTextureSubImage3D(name, 0, 0, 0, 0,
+				    IMAGE_WIDTH, IMAGE_HEIGHT, num_layers,
+				    GL_RGBA, GL_UNSIGNED_BYTE, data);
+		layer_size = IMAGE_SIZE;
+		break;
+
+	default:
+		puts("Invalid texture target.");
+		return PIGLIT_FAIL;
+
+	}
+
+	/* Make sure the driver has compressed the image. */
+	glGetTextureLevelParameteriv(name, 0, GL_TEXTURE_COMPRESSED,
+		&compressed);
+	printf("\tIs the texture compressed? %s.\n",
+		compressed ? "yes" : "no");
+
+	glGetTextureLevelParameteriv(name, 0,
+				     GL_TEXTURE_COMPRESSED_IMAGE_SIZE,
+				     &comp_size);
+	/*  The OpenGL 4.5 core spec
+	 *  (30.10.2014) Section 8.11 Texture Queries says:
+	 *       "For GetTextureLevelParameter* only, texture may also be a
+	 *       cube map texture object.  In this case the query is always
+	 *       performed for face zero (the TEXTURE_CUBE_MAP_POSITIVE_X
+	 *       face), since there is no way to specify another face."
+	 */
+	if (target == GL_TEXTURE_CUBE_MAP)
+		comp_size *= num_faces;
+	printf("\tThe size of the texture in bytes is %d.\n", comp_size);
+
+	/* Show the uncompressed data. */
+	show_image(data, num_layers * num_faces, "Data Before Compression");
+
+
+	/* Setup the PBO or data array to read into from
+	 * glGetCompressedTextureImage */
+	if (doPBO) {
+		glGenBuffers(1, &packPBO);
+		glBindBuffer(GL_PIXEL_PACK_BUFFER, packPBO);
+		/* Make the buffer big enough to hold uncompressed data. */
+		glBufferData(GL_PIXEL_PACK_BUFFER, layer_size * num_faces *
+			     num_layers * sizeof(GLubyte),
+			     NULL, GL_STREAM_READ);
+	} else {
+		glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+		data2 = malloc(layer_size * num_faces * num_layers *
+			       sizeof(GLubyte));
+		memset(data2, 123, layer_size * num_faces * num_layers *
+			       sizeof(GLubyte));
+	}
+	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
+	assert(num_layers * num_faces * layer_size <= 18 * IMAGE_SIZE);
+
+
+	/* Download the compressed texture image. */
+	if (doPBO)
+		glGetCompressedTextureImage(name, 0, comp_size, NULL);
+	else
+		glGetCompressedTextureImage(name, 0, comp_size, data2);
+	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
+
+	if (doPBO)
+		dataGet = (GLubyte *) glMapBufferRange(
+					       GL_PIXEL_PACK_BUFFER, 0,
+					       comp_size,
+					       GL_MAP_READ_BIT);
+	else
+		dataGet = data2;
+
+	/* Re-upload the texture in compressed form. */
+	switch (target) {
+	case GL_TEXTURE_2D:
+		glCompressedTextureSubImage2D(name, 0, 0, 0,
+					      IMAGE_WIDTH, IMAGE_HEIGHT,
+					      internalformat, comp_size,
+					      dataGet);
+		break;
+
+	case GL_TEXTURE_CUBE_MAP:
+		glCompressedTextureSubImage3D(name, 0, 0, 0, 0,
+					      IMAGE_WIDTH, IMAGE_HEIGHT,
+					      num_faces,
+					      internalformat, comp_size,
+					      dataGet);
+		break;
+
+	case GL_TEXTURE_2D_ARRAY:
+	case GL_TEXTURE_CUBE_MAP_ARRAY:
+		glCompressedTextureSubImage3D(name, 0, 0, 0, 0,
+					      IMAGE_WIDTH, IMAGE_HEIGHT,
+					      num_layers,
+					      internalformat, comp_size,
+					      dataGet);
+		break;
+	}
+
+
+	/* Get the uncompressed version for comparison. */
+	if (doPBO) {
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+		glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+			layer_size * num_layers * num_faces * sizeof(GLubyte),
+			NULL);
+	}
+	else {
+		glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE,
+			layer_size * num_layers * num_faces * sizeof(GLubyte),
+			data2);
+	}
+	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
+	if (doPBO)
+		dataGet = (GLubyte *) glMapBufferRange(
+					       GL_PIXEL_PACK_BUFFER, 0,
+					       layer_size * num_layers *
+					       num_faces * sizeof(GLubyte),
+					       GL_MAP_READ_BIT);
+	else
+		dataGet = data2;
+
+	/* Examine the image after pulling it off the graphics card. */
+	show_image(dataGet, num_layers * num_faces, "Data After Compression");
+
+	/* Do the comparison */
+	for (i = 0; i < num_faces * num_layers; i++) {
+		pass = compare_layer(i, layer_size, tolerance, dataGet,
+				     data + (i * layer_size)) && pass;
+		dataGet += layer_size;
+	}
+
+	if (doPBO) {
+		glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
+		glDeleteBuffers(1, &packPBO);
+	}
+
+	glDeleteTextures(1, &name);
+	free(data2);
+
+	return pass ? PIGLIT_PASS : PIGLIT_FAIL;
+}
+
+struct target_and_mask {
+	GLenum target;
+	bool mask;
+};
+
+static struct target_and_mask targets[] = {
+	{GL_TEXTURE_2D, 1},
+	{GL_TEXTURE_CUBE_MAP, 1},
+	{GL_TEXTURE_2D_ARRAY, 1},
+	{GL_TEXTURE_CUBE_MAP_ARRAY, 1},
+};
+
+static void
+clear_target_mask(GLenum target)
+{
+	int i;
+	for (i = 0; i < ARRAY_SIZE(targets); ++i) {
+		if (targets[i].target == target) {
+			targets[i].mask = 0;
+		}
+	}
+}
+
+void
+piglit_init(int argc, char **argv)
+{
+	piglit_require_extension("GL_ARB_direct_state_access");
+	piglit_require_extension("GL_ARB_texture_storage");
+
+	if (!piglit_is_extension_supported("GL_ARB_texture_cube_map"))
+		clear_target_mask(GL_TEXTURE_CUBE_MAP);
+	if (!piglit_is_extension_supported("GL_EXT_texture_array")) {
+		clear_target_mask(GL_TEXTURE_2D_ARRAY);
+	}
+	if (!piglit_is_extension_supported("GL_ARB_texture_cube_map_array"))
+		clear_target_mask(GL_TEXTURE_CUBE_MAP_ARRAY);
+
+	glClearColor(0.5, 0.5, 0.5, 1);
+	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
+}
+
+enum piglit_result
+piglit_display(void)
+{
+	int i;
+	GLenum internalformat = GL_COMPRESSED_RGBA_FXT1_3DFX;
+	int tolerance = 8;
+	GLubyte *data;
+	enum piglit_result subtest;
+	enum piglit_result result = PIGLIT_PASS;
+
+	piglit_require_extension("GL_3DFX_texture_compression_FXT1");
+
+	data = make_layer_data(18);
+
+	for (i = 0; i < ARRAY_SIZE(targets); ++i) {
+		if (!targets[i].mask)
+			continue;
+
+		printf("Testing %s into PBO\n",
+			piglit_get_gl_enum_name(targets[i].target));
+		subtest = getTexImage(true, targets[i].target, data,
+				      internalformat, tolerance);
+		piglit_report_subtest_result(subtest, "getTexImage %s PBO",
+					     piglit_get_gl_enum_name(
+						targets[i].target));
+		if (subtest == PIGLIT_FAIL)
+			result = PIGLIT_FAIL;
+
+		printf("\n"); /* Separate tests with some white space. */
+
+		printf("Testing %s into client array\n",
+			piglit_get_gl_enum_name(targets[i].target));
+		subtest = getTexImage(false, targets[i].target, data,
+				      internalformat, tolerance);
+		piglit_report_subtest_result(subtest, "getTexImage %s",
+					     piglit_get_gl_enum_name(
+						targets[i].target));
+		if (subtest == PIGLIT_FAIL)
+			result = PIGLIT_FAIL;
+
+		printf("\n\n"); /* Separate targets with some white space. */
+
+		if (!piglit_check_gl_error(GL_NO_ERROR))
+			result = PIGLIT_FAIL;
+	}
+
+	free(data);
+
+	return result;
+}
+
diff --git a/tests/util/piglit-util-gl.c b/tests/util/piglit-util-gl.c
index e6b773804..aae6df02a 100644
--- a/tests/util/piglit-util-gl.c
+++ b/tests/util/piglit-util-gl.c
@@ -2191,7 +2191,7 @@ piglit_rgbw_image(GLenum internalFormat, int w, int h,
 	return data;
 }
 
-static GLubyte *
+GLubyte *
 piglit_rgbw_image_ubyte(int w, int h, GLboolean alpha)
 {
 	GLubyte red[4]   = {255, 0, 0, 0};
diff --git a/tests/util/piglit-util-gl.h b/tests/util/piglit-util-gl.h
index adf98d805..9d6393c7d 100644
--- a/tests/util/piglit-util-gl.h
+++ b/tests/util/piglit-util-gl.h
@@ -201,6 +201,7 @@ GLuint piglit_checkerboard_texture(GLuint tex, unsigned level,
 GLuint piglit_miptree_texture(void);
 GLfloat *piglit_rgbw_image(GLenum internalFormat, int w, int h,
                            GLboolean alpha, GLenum basetype);
+GLubyte *piglit_rgbw_image_ubyte(int w, int h, GLboolean alpha);
 GLuint piglit_rgbw_texture(GLenum internalFormat, int w, int h, GLboolean mip,
 		    GLboolean alpha, GLenum basetype);
 GLuint piglit_depth_texture(GLenum target, GLenum format, int w, int h, int d, GLboolean mip);