[Piglit] [PATCH] arb_texture_multisample: stress test of very large textures (v2)

Brian Paul brianp at vmware.com
Sat Dec 23 21:37:12 UTC 2017


Create the largest possible 2D GL_RGBA_32F multisampled texture, load it
with known values the read it back and see if the values match up.

The --array option runs the test with a 2D texture array instead of an
MSAA texture.  There are other options to specify texture size, number of
samples, fp16 and a texel value scale.

Fails with NVIDIA's driver.  See code comments.

Note: The entry in all.py limits the texture size to 512x512 so it runs
in a reasonable amount of time.  Ideally, the texture size should be set
in quick.py instead but I've been unable to make that work.

v2:
* Fix a few code issues raised by Fabian Bieler, fix all.py, quick.py code.
* Update comments about NVIDIA driver, per Roland.
---
 tests/all.py                                       |   8 +
 tests/quick.py                                     |  17 +
 .../spec/arb_texture_multisample/CMakeLists.gl.txt |   1 +
 .../arb_texture_multisample/large-float-texture.c  | 728 +++++++++++++++++++++
 4 files changed, 754 insertions(+)
 create mode 100644 tests/spec/arb_texture_multisample/large-float-texture.c

diff --git a/tests/all.py b/tests/all.py
index 5d90e8f..d55cca9 100644
--- a/tests/all.py
+++ b/tests/all.py
@@ -1651,6 +1651,14 @@ with profile.test_list.group_manager(
 # Group ARB_texture_multisample
 with profile.test_list.group_manager(
         PiglitGLTest, grouptools.join('spec', 'ARB_texture_multisample')) as g:
+    g(['arb_texture_multisample-large-float-texture'], 'large-float-texture',
+      run_concurrent=False)
+    g(['arb_texture_multisample-large-float-texture', '--array'],
+      'large-float-texture-array', run_concurrent=False)
+    g(['arb_texture_multisample-large-float-texture', '--fp16'],
+      'large-float-texture-fp16', run_concurrent=False)
+    g(['arb_texture_multisample-large-float-texture', '--array', '--fp16'],
+      'large-float-texture-array-fp16', run_concurrent=False)
     g(['arb_texture_multisample-minmax'])
     g(['texelFetch', 'fs', 'sampler2DMS', '4', '1x71-501x71'])
     g(['texelFetch', 'fs', 'sampler2DMS', '4', '1x130-501x130'])
diff --git a/tests/quick.py b/tests/quick.py
index 1a7d674..53774e4 100644
--- a/tests/quick.py
+++ b/tests/quick.py
@@ -68,6 +68,23 @@ with profile.test_list.group_manager(
     with profile.test_list.allow_reassignment:
         g(['ext_texture_env_combine-combine', '--quick'], 'texture-env-combine')
 
+# Limit texture size to 512x512 for some texture_multisample tests.
+# The default (max supported size) can be pretty slow.
+with profile.test_list.group_manager(
+        PiglitGLTest,
+        grouptools.join('spec', 'ARB_texture_multisample')) as g:
+    with profile.test_list.allow_reassignment:
+        size_arg = ['--texsize', '512']
+        g(['arb_texture_multisample-large-float-texture'] + size_arg,
+          'large-float-texture', run_concurrent=False)
+        g(['arb_texture_multisample-large-float-texture', '--array'] +
+          size_arg, 'large-float-texture-array', run_concurrent=False)
+        g(['arb_texture_multisample-large-float-texture', '--fp16'] +
+          size_arg, 'large-float-texture-fp16', run_concurrent=False)
+        g(['arb_texture_multisample-large-float-texture', '--array',
+           '--fp16'] + size_arg,
+          'large-float-texture-array-fp16', run_concurrent=False)
+
 # These take too long
 profile.filters.append(lambda n, _: '-explosion' not in n)
 profile.filters.append(FilterVsIn())
diff --git a/tests/spec/arb_texture_multisample/CMakeLists.gl.txt b/tests/spec/arb_texture_multisample/CMakeLists.gl.txt
index a347143..31965c4 100644
--- a/tests/spec/arb_texture_multisample/CMakeLists.gl.txt
+++ b/tests/spec/arb_texture_multisample/CMakeLists.gl.txt
@@ -9,6 +9,7 @@ link_libraries (
 	${OPENGL_gl_LIBRARY}
 )
 
+piglit_add_executable (arb_texture_multisample-large-float-texture large-float-texture.c)
 piglit_add_executable (arb_texture_multisample-minmax minmax.c)
 piglit_add_executable (arb_texture_multisample-errors errors.c)
 piglit_add_executable (arb_texture_multisample-fb-completeness fb-completeness.c)
diff --git a/tests/spec/arb_texture_multisample/large-float-texture.c b/tests/spec/arb_texture_multisample/large-float-texture.c
new file mode 100644
index 0000000..3a77d43
--- /dev/null
+++ b/tests/spec/arb_texture_multisample/large-float-texture.c
@@ -0,0 +1,728 @@
+/*
+ * Copyright (c) 2017 VMware, Inc.
+ *
+ * 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 large-float-texture.c
+ *
+ * Test large MSAA float textures.  In particular, create/load a multisample
+ * texture then read it back and compare returned values.
+ * Also support array textures instead of MSAA as a sanity check / debug
+ * option.
+ *
+ * Some drivers/GPUs may fail this test.  NVIDIA, for example, appears to
+ * only store the MSAA coverage info, not the sample colors, for samples
+ * beyond the 8th sample.  We may tune the way this test operates over time
+ * to be more useful.  Maybe we should test all MSAA samples/pixels (2x,
+ * 4x, 8x, etc).
+ *
+ * See code for command line arguments.
+ */
+
+#include "piglit-util-gl.h"
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+	config.supports_gl_compat_version = 30;
+	config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DOUBLE;
+	config.khr_no_error_support = PIGLIT_NO_ERRORS;
+PIGLIT_GL_TEST_CONFIG_END
+
+
+static bool verbose = false;
+
+
+/**
+ * Try to create a GL_RGBA32F/16F texture of the given size, samples.
+ * Return 0 if failure.
+ */
+static GLuint
+create_texture(GLenum target, GLenum intFormat,
+	       GLsizei width, GLsizei height, GLuint numSamples)
+{
+	GLuint tex;
+
+	assert(intFormat == GL_RGBA32F || intFormat == GL_RGBA16F);
+
+	if (verbose) {
+		printf("Trying %d x %d  %d samples/layers\n",
+		       width, height, numSamples);
+	}
+
+	glGenTextures(1, &tex);
+	glBindTexture(target, tex);
+	if (target == GL_TEXTURE_2D_MULTISAMPLE) {
+		glTexImage2DMultisample(target,
+					numSamples, intFormat, width, height,
+					GL_FALSE); /* fixedsamplelocations */
+	}
+	else {
+		/* instead of samples per pixel, use 'samples' layers */
+		assert(target == GL_TEXTURE_2D_ARRAY);
+		glTexStorage3D(target, 1, intFormat, width, height,
+			       numSamples);
+	}
+
+	if (glGetError() != GL_NO_ERROR) {
+		/* some error */
+		glDeleteTextures(1, &tex);
+		tex = 0;
+	}
+
+	return tex;
+}
+
+
+/**
+ * Find the max working texture size.
+ */
+static GLuint
+create_texture_max_size(GLenum target, GLenum intFormat,
+			GLsizei *width, GLsizei *height,
+			GLuint numSamples)
+{
+	GLint w, h;
+	GLuint tex = 0;
+
+	w = *width;
+	h = *height;
+	while (w >= 1 && h >= 1) {
+		tex = create_texture(target, intFormat, w, h, numSamples);
+		if (tex) {
+			/* done! */
+			*width = w;
+			*height = h;
+			break;
+		}
+		/* try smaller size */
+		if (h >= w) {
+			h /= 2;
+		}
+		else {
+			w /= 2;
+		}
+	}
+
+	return tex;
+}
+
+
+/**
+ * Create an FBO which wraps the given texture.
+ */
+static GLuint
+create_fbo(GLuint tex, GLenum texTarget)
+{
+	GLuint fbo;
+
+	assert(texTarget == GL_TEXTURE_2D_MULTISAMPLE ||
+	       texTarget == GL_TEXTURE_2D_ARRAY ||
+	       texTarget == GL_TEXTURE_2D);
+
+	glGenFramebuffers(1, &fbo);
+	glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+	if (texTarget == GL_TEXTURE_2D_MULTISAMPLE ||
+	    texTarget == GL_TEXTURE_2D) {
+		glFramebufferTexture2D(GL_FRAMEBUFFER,
+				       GL_COLOR_ATTACHMENT0,
+				       texTarget, tex, 0);  /* 0=level */
+	}
+	else {
+		assert(texTarget == GL_TEXTURE_2D_ARRAY);
+		glFramebufferTextureLayer(GL_FRAMEBUFFER,
+					  GL_COLOR_ATTACHMENT0,
+					  tex, 0, 0);
+	}
+
+	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+	if (status != GL_FRAMEBUFFER_COMPLETE) {
+		if (verbose) {
+			printf("Failed to create FBO! (status = %s)\n",
+			       piglit_get_gl_enum_name(status));
+		}
+		glDeleteFramebuffers(1, &fbo);
+		fbo = 0;
+	}
+
+	return fbo;
+}
+
+
+/**
+ * Load the GL_RGBA32F/16F MSAA (or array) texture with known values.
+ * The color components are basically:
+ *  x = texcoord in [0, 1]  (this can get fuzzy for large texture widths)
+ *  y = fragcoord.y MOD 16 in [0, 15]
+ *  z = -curSample in [-(numSamples-1), 0]
+ *  w = curSample in [0, numSamples-1]
+ */
+static void
+load_texture_image(GLenum target, GLuint fbo, GLuint tex,
+		   GLsizei width, GLsizei height, GLuint numSamples,
+		   GLfloat valueScale)
+{
+	static const char *vs_text =
+		"#version 130\n"
+		"out vec4 texcoord;\n"
+		"void main() {\n"
+		"  texcoord = gl_MultiTexCoord0;\n"
+		"  gl_Position = gl_Vertex;\n"
+		"}\n";
+	static const char *fs_text =
+		"#version 130\n"
+		"out vec4 color;\n"
+		"in vec4 texcoord;\n"
+		"uniform int curSample;\n"
+		"uniform float valueScale;\n"
+		"void main() {\n"
+		"   float x = texcoord.x; \n"
+		"   float y = float(int(gl_FragCoord.y) % 16) / 16.0; \n"
+		"   float z = -curSample; \n"
+		"   float w = curSample; \n"
+		"   color = valueScale * vec4(x, y, z, w); \n"
+		"}\n";
+
+	GLuint prog;
+
+	prog = piglit_build_simple_program(vs_text, fs_text);
+
+	assert(prog);
+	assert(numSamples <= 32);
+
+	glUseProgram(prog);
+
+	GLint curSampleUniform = glGetUniformLocation(prog, "curSample");
+	assert(curSampleUniform >= 0);
+
+	GLint valueScaleUniform = glGetUniformLocation(prog, "valueScale");
+	glUniform1f(valueScaleUniform, valueScale);
+
+	if (target == GL_TEXTURE_2D_MULTISAMPLE) {
+		glEnable(GL_SAMPLE_MASK);
+		glEnable(GL_MULTISAMPLE);
+	}
+
+	GLint samp;
+	for (samp = 0; samp < numSamples; samp++) {
+		if (verbose) {
+			printf("Render sample/layer %d\n", samp);
+		}
+
+		glUniform1i(curSampleUniform, samp);
+
+		/* choose sample or layer to write to */
+		if (target == GL_TEXTURE_2D_MULTISAMPLE) {
+			glSampleMaski(0, 1u << samp);
+		}
+		else {
+			assert(target == GL_TEXTURE_2D_ARRAY);
+			glFramebufferTextureLayer(GL_FRAMEBUFFER,
+						  GL_COLOR_ATTACHMENT0,
+						  tex, 0, samp);
+		}
+
+		/* Full framebuffer rect */
+		piglit_draw_rect_tex(-1, -1, 2, 2,
+				     0, 0, 1, 1);
+	}
+
+	if (target == GL_TEXTURE_2D_MULTISAMPLE) {
+		glDisable(GL_SAMPLE_MASK);
+		glDisable(GL_MULTISAMPLE);
+	}
+
+	glDeleteProgram(prog);
+}
+
+
+/**
+ * Create simple 2D, GL_RGBA32F texture of given size.
+ */
+static GLuint
+create_float4_tex(GLsizei width, GLsizei height)
+{
+	GLuint tex;
+
+	glGenTextures(1, &tex);
+	glBindTexture(GL_TEXTURE_2D, tex);
+	glTexStorage2D(GL_TEXTURE_2D, 1, GL_RGBA32F, width, height);
+
+	if (glGetError() != GL_NO_ERROR) {
+		glDeleteTextures(1, &tex);
+		tex = 0;
+	}
+	return tex;
+}
+
+
+/**
+ * Create the shader program needed for extracting texels from an
+ * MSAA (or array) texture.
+ */
+static GLuint
+create_readback_program(GLenum target)
+{
+	static const char *fs_text_msaa =
+		"#version 130\n"
+		"#extension GL_ARB_texture_multisample : enable\n"
+		"out vec4 color;\n"
+		"uniform sampler2DMS tex;\n"
+		"uniform int sample;\n"
+		"void main() {\n"
+		"  ivec2 coord = ivec2(gl_FragCoord.xy);\n"
+		"  color = texelFetch(tex, coord, sample);\n"
+		"}\n";
+
+	static const char *fs_text_array =
+		"#version 130\n"
+		"out vec4 color;\n"
+		"uniform sampler2DArray tex;\n"
+		"uniform int sample;\n"
+		"void main() {\n"
+		"  ivec2 coord = ivec2(gl_FragCoord.xy);\n"
+		"  color = texelFetch(tex, ivec3(coord, sample), 0);\n"
+		"}\n";
+
+	const char *fs_text = target == GL_TEXTURE_2D_MULTISAMPLE ?
+		fs_text_msaa : fs_text_array;
+
+	GLuint prog = piglit_build_simple_program(NULL, fs_text);
+
+	assert(prog);
+
+	return prog;
+}
+
+/**
+ * Extract a slice or per-sample image from the src_tex.
+ */
+static void
+extract_texture_image(GLuint readbackProg,
+		      GLuint src_tex, GLsizei width, GLsizei height,
+		      GLuint sample)
+{
+	glUseProgram(readbackProg);
+
+	GLint texUniform = glGetUniformLocation(readbackProg, "tex");
+	GLint sampleUniform = glGetUniformLocation(readbackProg, "sample");
+
+	/* Create texture to put results into, and wrap it in an FBO.
+	 * The shader will extract the sample from the MSAA texture (or
+	 * array layer) and write the results into a destination texture/FBO.
+	 */
+	GLuint dst_tex = create_float4_tex(width, height);
+	GLuint dst_fbo = create_fbo(dst_tex, GL_TEXTURE_2D);
+
+	glUniform1i(texUniform, 0);  // unit 0
+	glUniform1i(sampleUniform, sample);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, dst_fbo);
+
+	piglit_draw_rect_tex(-1, -1, 2, 2,
+			     0, 0, 1, 1);
+
+	glBindTexture(GL_TEXTURE_2D, dst_tex);
+
+	/* Now, the extracted image is available both as dst_tex
+	 * and as the current FBO.
+	 */
+}
+
+
+/**
+ * Test if two float[4] values are nearly equal.
+ */
+static bool
+nearly_equal(const GLfloat x[4], const GLfloat y[4])
+{
+	/* XXX this tolerance was chosen emperically */
+	const float maxRelDiff = 0.0005;
+	int i;
+	for (i = 0; i < 4; i++) {
+		float diff = x[i] - y[i];
+		float ax = fabsf(x[i]), ay = fabsf(y[i]);
+		if (diff > MAX2(ax, ay) * maxRelDiff) {
+			return false;
+		}
+	}
+
+	return true;
+}
+
+
+/**
+ * To record +/- max difference between expected and rendered results.
+ */
+struct error_info
+{
+	float min_error[4], max_error[4];
+	float avg_error[4];
+	unsigned num_fail;
+};
+
+
+static void
+init_error_info(struct error_info *err)
+{
+	int i;
+	for (i = 0; i < 4; i++) {
+		err->min_error[i] = 1e20;
+		err->max_error[i] = -1e20;
+		err->avg_error[i] = 0.0;
+	}
+	err->num_fail = 0;
+}
+
+
+static bool
+nonzero(const float a[4])
+{
+	return a[0] != 0.0 ||a[1] != 0.0 ||a[2] != 0.0 ||a[3] != 0.0;
+}
+
+
+static void
+finish_and_print_error_info(struct error_info *err,
+			    GLsizei width, GLsizei height)
+{
+	int i;
+	for (i = 0; i < 4; i++) {
+		err->avg_error[i] /= width * height;
+	}
+	if (verbose ||
+	    nonzero(err->min_error) ||
+	    nonzero(err->max_error) ||
+	    nonzero(err->avg_error)) {
+		printf("Min error: %g %g %g %g\n",
+		       err->min_error[0], err->min_error[1],
+		       err->min_error[2], err->min_error[3]);
+		printf("Max error: %g %g %g %g\n",
+		       err->max_error[0], err->max_error[1],
+		       err->max_error[2], err->max_error[3]);
+		printf("Avg error: %g %g %g %g\n",
+		       err->avg_error[0], err->avg_error[1],
+		       err->avg_error[2], err->avg_error[3]);
+		printf("num_fail: %u\n", err->num_fail);
+	}
+}
+
+
+static void
+update_error_info(struct error_info *err,
+		  const GLfloat a[4], const GLfloat b[4])
+{
+	bool fail = false;
+	int i;
+
+	for (i = 0; i < 4; i++) {
+		float delta = a[i] - b[i];
+		err->min_error[i] = MIN2(err->min_error[i], delta);
+		err->max_error[i] = MAX2(err->max_error[i], delta);
+
+		err->avg_error[i] += fabsf(delta);
+
+		if (delta != 0.0f) {
+			fail = true;
+		}
+	}
+
+	err->num_fail += (unsigned) fail;
+}
+
+
+static unsigned
+texel_size(GLenum intFormat)
+{
+	switch (intFormat) {
+	case GL_RGBA16F:
+		return 4 * sizeof(GLhalf);
+	case GL_RGBA32F:
+		return 4 * sizeof(GLfloat);
+	default:
+		assert(!"Unexpected texture format");
+	}
+}
+
+
+/**
+ * Read back all texture samples, compare to reference.
+ */
+static bool
+validate_texture_image(GLenum target,
+		       GLenum intFormat,
+		       GLuint readbackProg,
+		       GLuint src_tex,
+		       GLsizei width, GLsizei height, GLuint numSamples,
+		       GLfloat valueScale)
+{
+	/*
+	 * Note: this is a little more complicated than just mallocing
+	 * a buffer of size width * height * numSamples * texelSize
+	 * because we could easily exceed 4GB.  So, we read back the image
+	 * in stripes no larger than 512MB.
+	 */
+	const size_t buffer_size = 512 * 1024 * 1024;  // 512 MB
+	GLfloat *buffer = malloc(buffer_size);
+	assert(buffer);
+
+	const int bytesPerRow = width * numSamples * texel_size(intFormat);
+	const int stripeHeight = MIN2(buffer_size / bytesPerRow, height);
+
+	bool pass = true;
+	float fwidth = (float) width;
+	GLuint samp;
+
+	glBindTexture(target, src_tex);
+
+	for (samp = 0; samp < numSamples; samp++) {
+		struct error_info err;
+
+		init_error_info(&err);
+
+		if (verbose) {
+			printf("Checking sample/layer %d\n", samp);
+		}
+
+		extract_texture_image(readbackProg, src_tex,
+				      width, height, samp);
+
+		GLint i, j, numFail = 0;
+
+		for (j = 0; j < height; j++) {
+
+			if (j % stripeHeight == 0) {
+				/* read a stripe */
+				if (height == stripeHeight) {
+					/* get whole texture with GetTexImage */
+					glGetTexImage(GL_TEXTURE_2D, 0,
+						      GL_RGBA, GL_FLOAT,
+						      buffer);
+				}
+				else {
+					/* use glReadPixels to get a stripe */
+					glReadPixels(0, j, width, stripeHeight,
+						     GL_RGBA, GL_FLOAT, buffer);
+				}
+			}
+
+			for (i = 0; i < width; i++) {
+				int row = j % stripeHeight;
+				const GLfloat *texel =
+					buffer + (width * row + i) * 4;
+				GLfloat expected[4];
+
+				/* [0] is texcoord at center of fragment */
+				expected[0] = i / fwidth + (0.5f / fwidth);
+				/* [1] is fragcoord.y MOD 16 / 16.0 */
+				expected[1] = (j % 16) / 16.0;
+				expected[2] = -1.0 * samp;
+				expected[3] = samp;
+
+				expected[0] *= valueScale;
+				expected[1] *= valueScale;
+				expected[2] *= valueScale;
+				expected[3] *= valueScale;
+
+				update_error_info(&err, texel, expected);
+
+				if (!nearly_equal(texel, expected)) {
+					printf("Fail at %d, %d:\n", i, j);
+					printf("  Expected %g, %g, %g, %g\n",
+					       expected[0], expected[1],
+					       expected[2], expected[3]);
+					printf("  Found %g, %g, %g, %g\n",
+					       texel[0], texel[1],
+					       texel[2], texel[3]);
+					pass = false;
+					numFail++;
+					if (numFail >= 5) {
+						goto end;
+					}
+				}
+			}
+		}
+		finish_and_print_error_info(&err, width, height);
+	}
+
+end:
+	free(buffer);
+
+	return pass;
+}
+
+
+void
+piglit_init(int argc, char **argv)
+{
+	GLenum target = GL_TEXTURE_2D_MULTISAMPLE;
+	GLenum intFormat = GL_RGBA32F;
+	GLint samples = -1;  /* or array slices */
+	GLint maxSize = -1;
+	GLsizei width = -1, height = -1;
+	GLfloat valueScale = 1.0;
+	int i;
+
+	for (i = 1; i < argc; i++) {
+		if (strcmp(argv[i], "--array") == 0) {
+			target = GL_TEXTURE_2D_ARRAY;
+		}
+		else if (strcmp(argv[i], "--samples") == 0) {
+			i++;
+			samples = atoi(argv[i]);
+			assert(samples > 0);
+		}
+		else if (strcmp(argv[i], "--texsize") == 0) {
+			i++;
+			maxSize = atoi(argv[i]);
+			assert(maxSize > 0);
+		}
+		else if (strcmp(argv[i], "--width") == 0) {
+			i++;
+			width = atoi(argv[i]);
+			assert(width > 0);
+		}
+		else if (strcmp(argv[i], "--height") == 0) {
+			i++;
+			height = atoi(argv[i]);
+			assert(height > 0);
+		}
+		else if (strcmp(argv[i], "--scale") == 0) {
+			i++;
+			valueScale = atof(argv[i]);
+			assert(valueScale > 0.0);
+		}
+		else if (strcmp(argv[i], "--fp16") == 0) {
+			intFormat = GL_RGBA16F;
+		}
+		else if (strcmp(argv[i], "--verbose") == 0) {
+			verbose = true;
+		}
+		else {
+			printf("Unknown option %s\n", argv[i]);
+			piglit_report_result(PIGLIT_FAIL);
+		}
+	}
+
+	piglit_require_extension("GL_ARB_texture_float");
+	piglit_require_extension("GL_ARB_texture_multisample");
+	piglit_require_GLSL_version(130);
+
+	if (maxSize == -1) {
+		glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxSize);
+	}
+
+	if (samples == -1) {
+		if (target == GL_TEXTURE_2D_MULTISAMPLE) {
+			glGetIntegerv(GL_MAX_COLOR_TEXTURE_SAMPLES, &samples);
+		}
+		else {
+			samples = 16;  /* 16 texture array layers */
+		}
+	}
+
+	GLuint tex, fbo = 0;
+
+	if (width == -1 || height == -1) {
+		width = height = maxSize;
+	}
+
+	while (width > 1 && height > 1) {
+		tex = create_texture_max_size(target, intFormat,
+					      &width, &height, samples);
+
+		if (!tex) {
+			printf("Failed to create MSAA texture\n");
+			piglit_report_result(PIGLIT_FAIL);
+		}
+
+		fbo = create_fbo(tex, target);
+		if (!fbo) {
+			/* texture creation worked, but FBO failed.
+			 * Try smaller texture.
+			 */
+			glDeleteTextures(1, &tex);
+			if (height >= width) {
+				height /= 2;
+			}
+			else {
+				width /= 2;
+			}
+		}
+		else {
+			break;
+		}
+	}
+
+	if (!fbo) {
+		printf("Failed to create FBO\n");
+		piglit_report_result(PIGLIT_SKIP);
+	}
+
+	GLint64 mbytes = (GLint64) width * height * samples
+		* texel_size(intFormat) / (1024 * 1024);
+
+	const char *formatName = piglit_get_gl_enum_name(intFormat);
+	if (target == GL_TEXTURE_2D_ARRAY) {
+		printf("Created %d x %d %d-layer %s texture/FBO"
+		       " (%lld MB)\n",
+		       width, height, samples, formatName,
+		       (long long int) mbytes);
+	}
+	else {
+		printf("Created %d x %d %d-sample MSAA %s texture/FBO"
+		       " (%lld MB)\n",
+		       width, height, samples, formatName,
+		       (long long int) mbytes);
+	}
+
+	GLuint readbackProg = create_readback_program(target);
+
+	glViewport(0, 0, width, height);
+	glClampColor(GL_CLAMP_READ_COLOR, GL_FALSE);
+	glClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);
+
+	if (verbose) {
+		printf("Loading...\n");
+	}
+
+	load_texture_image(target, fbo, tex, width, height,
+			   samples, valueScale);
+
+	if (verbose) {
+		printf("Validating...\n");
+	}
+
+	bool pass = validate_texture_image(target, intFormat, readbackProg, tex,
+					   width, height, samples, valueScale);
+
+	if (!piglit_check_gl_error(GL_NO_ERROR)) {
+		pass = false;
+	}
+
+	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
+}
+
+
+enum piglit_result
+piglit_display(void)
+{
+	/* should never get here */
+	return PIGLIT_FAIL;
+}
-- 
1.9.1



More information about the Piglit mailing list