Example #1
0
void
piglit_init(int argc, char **argv)
{
	GLuint tex, view;
	GLuint buffer;
	int i, j;
	bool use_pbo = false;
	bool pass = true;

#ifdef PIGLIT_USE_OPENGL
	piglit_require_extension("GL_ARB_texture_view");
#else
	piglit_require_extension("GL_OES_texture_view");
#endif

	for (i = 1; i < argc; ++i) {
		if (strcmp(argv[i], "pbo") == 0) {
			piglit_require_extension("GL_ARB_pixel_buffer_object");
			use_pbo = true;
		}
	}

	/* build a texture with full miptree */
	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D, tex);
	glTexStorage2D(GL_TEXTURE_2D, NUM_LEVELS,
		       GL_RGBA8, TEX_SIZE, TEX_SIZE);

	if (use_pbo) {
		glGenBuffers(1, &buffer);
		glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
	}

	for (i=0; i < NUM_LEVELS; i++) {
		int dim = TEX_SIZE >> i;
		GLubyte *pixels = create_solid_image(dim, dim, 1, 4, i);
		if (!pixels) {
			printf("Failed to allocate image for level %d\n", i);
			piglit_report_result(PIGLIT_FAIL);
		}

		if (use_pbo) {
			glBufferData(GL_PIXEL_UNPACK_BUFFER, dim * dim * 4,
				     pixels, GL_STREAM_DRAW);
		}
		glTexSubImage2D(GL_TEXTURE_2D,
				i, 0, 0, dim, dim,
				GL_RGBA, GL_UNSIGNED_BYTE, use_pbo ? NULL : pixels);
		free(pixels);
	}

	/* create a view to a subset of the layers */
	glGenTextures(1, &view);
	glTextureView(view, GL_TEXTURE_2D, tex, GL_RGBA8,
		      VIEW_MIN_LEVEL, VIEW_NUM_LEVELS, 0, 1);

	if (!piglit_check_gl_error(GL_NO_ERROR))
		piglit_report_result(PIGLIT_FAIL);

	/* upload through the view */
	glBindTexture(GL_TEXTURE_2D, view);
	for (i = 0; i < VIEW_NUM_LEVELS; i++) {
		int dim = TEX_SIZE >> (VIEW_MIN_LEVEL + i);
		GLubyte *pixels = create_solid_image(dim, dim,
						     1, 4, i + NUM_LEVELS);
		if (!pixels) {
			printf("Failed to allocate image for view level %d\n", i);
			piglit_report_result(PIGLIT_FAIL);
		}

		if (use_pbo) {
			glBufferData(GL_PIXEL_UNPACK_BUFFER, dim * dim * 4,
				     pixels, GL_STREAM_DRAW);
		}
		glTexSubImage2D(GL_TEXTURE_2D, i, 0, 0, dim, dim,
				GL_RGBA, GL_UNSIGNED_BYTE, use_pbo ? NULL : pixels);
		free(pixels);
	}

	if (!piglit_check_gl_error(GL_NO_ERROR))
		piglit_report_result(PIGLIT_FAIL);

	/* bind the underlying texture and readback */
	glBindTexture(GL_TEXTURE_2D, tex);
	for (i = 0; i < NUM_LEVELS; i++) {
		/* the levels inside the view should have been replaced.
		 * everything else should be untouched.
		 */

		float expected_color[4];
		int dim = TEX_SIZE >> i;
		int color_index = i;
		if (i >= VIEW_MIN_LEVEL &&
		    i < VIEW_MIN_LEVEL + VIEW_NUM_LEVELS) {
			color_index = i + NUM_LEVELS - VIEW_MIN_LEVEL;
		}

		printf("Testing level %d\n", i);

		for (j = 0; j < 4; j++)
			expected_color[j] = Colors[color_index][j] / 255.0f;

		pass = piglit_probe_texel_rect_rgba(GL_TEXTURE_2D,
						    i, 0, 0, dim, dim,
						    expected_color) && pass;
	}

	if (use_pbo)
		glDeleteBuffers(1, &buffer);

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
Example #2
0
/**
 * Simple views  of textures; test rendering with various texture view targets
 */
static bool
test_render_with_targets(GLenum target)
{
	GLuint tex, newTex;
	GLint width = 128, height = 64, depth = 4, levels = 8;
	GLint l;
	bool pass = true;

	glUseProgram(0);
	glGenTextures(1, &tex);
	glBindTexture(target, tex);

	switch (target) {
	case GL_TEXTURE_1D:
		glTexStorage1D(target, levels, GL_RGBA8, width);
		height = 1;
		depth = 1;
		break;
	case GL_TEXTURE_2D:
		glTexStorage2D(target, levels, GL_RGBA8, width, height);
		depth = 1;
		break;
	case GL_TEXTURE_3D:
	case GL_TEXTURE_2D_ARRAY:
		glTexStorage3D(target, levels, GL_RGBA8, width, height, depth);
		break;
	default:
		/* only handle subset of legal targets */
		piglit_report_result(PIGLIT_FAIL);
		assert(!"Illegal target for test_render_with_targets()\n");
		break;
	}

	/* load each mipmap with a different color texture */
	for (l = 0; l < levels; l++) {
		GLubyte *buf = create_solid_image(width, height, depth, 4, l);

		if (buf != NULL) {
			switch(target) {
			case GL_TEXTURE_1D:
				glTexSubImage1D(GL_TEXTURE_1D, l, 0, width,
						GL_RGBA, GL_UNSIGNED_BYTE, buf);
				break;
			case GL_TEXTURE_2D:
				glTexSubImage2D(GL_TEXTURE_2D, l, 0, 0, width,
						height, GL_RGBA,
						GL_UNSIGNED_BYTE, buf);
				break;
			case GL_TEXTURE_3D:
			case GL_TEXTURE_2D_ARRAY:
				glTexSubImage3D(target, l, 0, 0, 0, width,
						height, depth, GL_RGBA,
						GL_UNSIGNED_BYTE, buf);
				break;
			}
			free(buf);
		} else {
			piglit_report_result(PIGLIT_FAIL);
			assert(!"create_solid_image() failed\n");
		}

		if (width > 1)
			width /= 2;
		if (height > 1)
			height /= 2;
		if (depth > 1 && target == GL_TEXTURE_3D)
			depth /= 2;
	}

	if (piglit_check_gl_error(GL_NO_ERROR) == GL_FALSE) {
		printf("%s: Found gl errors prior to testing glTextureView\n",
				   TestName);
		glDeleteTextures(1, &tex);

		return false;
	}

	/* create view of texture and bind it to target */
	glGenTextures(1, &newTex);
	glTextureView(newTex, target, tex,  GL_RGBA8, 0, levels, 0, 1);
	glDeleteTextures(1, &tex);
	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(target, newTex);

	/* draw a quad/line using each texture mipmap level */
	glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
			GL_NEAREST_MIPMAP_NEAREST);
	glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	for (l = 0; l < levels; l++) {
		GLfloat expected[3];
		int p;

		glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, l);
		glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, l);

		glClear(GL_COLOR_BUFFER_BIT);

		switch (target) {
		case GL_TEXTURE_1D:
			glUseProgram(prog1D);
			glUniform1i(tex_loc_1D, 0);
			piglit_draw_rect_tex(-1.0, -1.0, 2.0, 2.0, 0.0, 0.0,
					     1.0, 1.0);
			break;
		case GL_TEXTURE_2D:
			glEnable(target);
			piglit_draw_rect_tex(-1.0, -1.0, 2.0, 2.0, 0.0, 0.0,
					     1.0, 1.0);
			glDisable(target);
			break;
		case GL_TEXTURE_2D_ARRAY:
			glUseProgram(prog2Darray);
			glUniform1i(tex_loc_2Darray, 0);
			draw_3d_depth(-1.0, -1.0, 2.0, 2.0, l);
			break;
		case GL_TEXTURE_3D:
			glEnable(target);
			draw_3d_depth(-1.0, -1.0, 2.0, 2.0, l);
			glDisable(target);
			break;
		}

		expected[0] = Colors[l][0] / 255.0;
		expected[1] = Colors[l][1] / 255.0;
		expected[2] = Colors[l][2] / 255.0;

		p = piglit_probe_pixel_rgb(piglit_width/2, piglit_height/2,
					   expected);

		piglit_present_results();

#if 0		/* debug */
		printf("for level=%d, target=%s, expected color=%f %f %f\n",
			   l, piglit_get_gl_enum_name(target), expected[0],
				   expected[1], expected[2]);
		sleep(1);
#endif

		if (!p) {
			printf("%s: wrong color for mipmap level %d\n",
			       TestName, l);
			pass = false;
		}
	}
	glDeleteTextures(1, &newTex);

	return pass;
}
Example #3
0
/**
 * Texture views with varying minimum and number of levels, 2D only
 */
static bool
test_render_levels(void)
{
	GLuint tex, new_tex;
	GLint width = 4096, height = 4096, levels =13;
	GLuint numLevels[] = {3,2,2,1};
	GLint l;
	int expectedLevel;
	GLfloat expected[3];
	int p;
	bool pass = true;

	glUseProgram(0);

	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D, tex);

	glTexStorage2D(GL_TEXTURE_2D, levels, GL_RGBA8, width, height);
	glEnable(GL_TEXTURE_2D);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	/* load each mipmap with a different color texture */
	for (l = 0; l < levels; l++) {
		GLubyte *buf = create_solid_image(width, height, 1, 4, l);

		if (buf != NULL) {
			glTexSubImage2D(GL_TEXTURE_2D, l, 0, 0, width, height,
					GL_RGBA, GL_UNSIGNED_BYTE, buf);
			free(buf);
		}

		if (width > 1)
			width /= 2;
		if (height > 1)
			height /= 2;
	}

	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;

	/* create view of texture with restricted levels and draw quad */
	/* using smallest mip level in the view range which varies every loop */
	for (l = 0; l < ARRAY_SIZE(numLevels); l++) {
		glGenTextures(1, &new_tex);
		glTextureView(new_tex, GL_TEXTURE_2D, tex,  GL_RGBA8, l,
			      numLevels[l], 0, 1);
		glBindTexture(GL_TEXTURE_2D, new_tex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, levels-1);

		glClear(GL_COLOR_BUFFER_BIT);

		piglit_draw_rect_tex(-1.0, -1.0, 2.0/(float) (l+2),
				     2.0/ (float) (l+2), 0.0, 0.0, 1.0, 1.0);

		expectedLevel = l + numLevels[l] - 1;
		expected[0] = Colors[expectedLevel][0] / 255.0;
		expected[1] = Colors[expectedLevel][1] / 255.0;
		expected[2] = Colors[expectedLevel][2] / 255.0;

		p = piglit_probe_pixel_rgb(piglit_width/(2*(l+3)),
					   piglit_height/(2*(l+3)), expected);

		piglit_present_results();

#if 0
		{  /* debug */
			GLint param;
			glGetTexParameteriv(GL_TEXTURE_2D,
					    GL_TEXTURE_BASE_LEVEL, &param);
			printf("for view min level=%d base_level=%d exp color=%f %f %f\n",
			       l, param, expected[0], expected[1], expected[2]);
			glGetTexParameteriv(GL_TEXTURE_2D,
					    GL_TEXTURE_MAX_LEVEL, &param);
			printf("max_level=%d\n", param);
			glGetTexParameteriv(GL_TEXTURE_2D,
					    GL_TEXTURE_VIEW_MIN_LEVEL, &param);
			printf("view min_level=%d\n", param);
			glGetTexParameteriv(GL_TEXTURE_2D,
					    GL_TEXTURE_VIEW_NUM_LEVELS, &param);
			printf("view num_level=%d\n", param);
			glGetTexParameteriv(GL_TEXTURE_2D,
					    GL_TEXTURE_IMMUTABLE_LEVELS,
					    &param);
			printf("immutable levels=%d\n", param);
			sleep(1);
		}
#endif

		if (!p) {
			printf("%s: wrong color for view min level %d, expectedLevel %d\n",
				   TestName, l, expectedLevel);
			pass = false;
		}
		glDeleteTextures(1, &new_tex);
	}

	glDisable(GL_TEXTURE_2D);
	glDeleteTextures(1, &tex);
	return pass;
}
Example #4
0
/**
 * Views  with varying minimum  and number of layers 2D_ARRAY only
 */
static bool
test_render_layers(void)
{
	GLuint tex, new_tex;
	GLint width = 16, height = 16, layers = 8;
	GLint l;
	GLint numLayers[] = {7, 1, 2, 2};
	int expectedLayer;
	GLfloat expected[3];
	int p;
	bool pass = true;

	glUseProgram(prog2Darray);
	glUniform1i(tex_loc_2Darray, 0);

	glGenTextures(1, &tex);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D_ARRAY, tex);

	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_BASE_LEVEL, 0);
	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAX_LEVEL, 0);
	glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, width, height, layers);

	/* load each array layer with a different color texture */
	for (l = 0; l < layers; l++) {
		GLubyte *buf = create_solid_image(width, height, 1, 4, l);

		if (buf != NULL) {
			glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, l,
					width, height, 1, GL_RGBA,
					GL_UNSIGNED_BYTE, buf);
			free(buf);
		}

	}

	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;

	/* create view of texture with restricted layers and draw quad */
	/* using a single layer in the view range which varies every loop */
	for (l = 0; l < ARRAY_SIZE(numLayers); l++) {
		glGenTextures(1, &new_tex);
		glTextureView(new_tex, GL_TEXTURE_2D_ARRAY, tex,  GL_RGBA8,
			      0, 1, l, numLayers[l]);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D_ARRAY, new_tex);

		glClear(GL_COLOR_BUFFER_BIT);

		expectedLayer = l + numLayers[l] - 1;
		draw_3d_depth(-1.0, -1.0, 2.0, 2.0, expectedLayer);

		expected[0] = Colors[expectedLayer][0] / 255.0;
		expected[1] = Colors[expectedLayer][1] / 255.0;
		expected[2] = Colors[expectedLayer][2] / 255.0;

		p = piglit_probe_pixel_rgb(piglit_width/2, piglit_height/2,
					   expected);

		piglit_present_results();

#if 0
		printf("for view min layer=%d expectedLayer=%d expected color=%f %f %f\n",
		       l, expectedLayer, expected[0], expected[1], expected[2]);
		sleep(1);
#endif

		if (!p) {
			printf("%s: wrong color for view min layer %d, expectedLayer %d\n",
			       TestName, l, expectedLayer);
			pass = false;
		}
		glDeleteTextures(1, &new_tex);
	}

	glDeleteTextures(1, &tex);
	return pass;
}
void
piglit_init(int argc, char **argv)
{
	GLuint tex, view, scratch;
	GLuint fbo;
	int i, j;
	bool pass = true;

	piglit_require_extension("GL_ARB_texture_storage");
	piglit_require_extension("GL_ARB_texture_view");

	/* build a 2d array texture; no mip levels */
	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
	glTexStorage3D(GL_TEXTURE_2D_ARRAY, 1,
		GL_RGBA8, TEX_SIZE, TEX_SIZE, NUM_LAYERS);

	for (i=0; i < NUM_LAYERS; i++) {
		GLubyte *pixels = create_solid_image(TEX_SIZE, TEX_SIZE,
						     1, 4, i);
		if (!pixels) {
			printf("Allocation failure for layer %d\n", i);
			piglit_report_result(PIGLIT_FAIL);
		}
		glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0,
				0, 0, i, TEX_SIZE, TEX_SIZE, 1,
				GL_RGBA, GL_UNSIGNED_BYTE, pixels);
		free(pixels);
	}

	/* create a view of just one layer, as a non-array 2d texture */
	glGenTextures(1, &view);
	glTextureView(view, GL_TEXTURE_2D, tex, GL_RGBA8,
		      0, 1, VIEW_MIN_LAYER, VIEW_NUM_LAYERS);

	if (!piglit_check_gl_error(GL_NO_ERROR))
		piglit_report_result(PIGLIT_FAIL);

	/* create scratch fbo, clear into it */
	glGenFramebuffers(1, &fbo);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
	glGenTextures(1, &scratch);
	glBindTexture(GL_TEXTURE_2D, scratch);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, TEX_SIZE,
		     TEX_SIZE, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
	glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
			       GL_TEXTURE_2D, scratch, 0);
	if (glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		piglit_report_result(PIGLIT_FAIL);
	glViewport(0, 0, TEX_SIZE, TEX_SIZE);

	glClearColor(Colors[NUM_LAYERS][0] / 255.0f,
		     Colors[NUM_LAYERS][1] / 255.0f,
		     Colors[NUM_LAYERS][2] / 255.0f,
		     Colors[NUM_LAYERS][3] / 255.0f);
	glClear(GL_COLOR_BUFFER_BIT);

	/* glCopyTexSubImage2D out of the scratch fbo */
	glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
	glReadBuffer(GL_COLOR_ATTACHMENT0);
	glBindTexture(GL_TEXTURE_2D, view);
	glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0,
			    0, 0, TEX_SIZE, TEX_SIZE);

	if (!piglit_check_gl_error(GL_NO_ERROR))
		piglit_report_result(PIGLIT_FAIL);

	/* bind the underlying texture and readback */
	glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
	for (i = 0; i < NUM_LAYERS; i++) {
		/* only the layer in the view should have been touched. */
		int color_index;
		float expected_color[4];

		color_index = i;
		if (i >= VIEW_MIN_LAYER && i < VIEW_MIN_LAYER + VIEW_NUM_LAYERS)
			color_index = i + NUM_LAYERS - VIEW_MIN_LAYER;

		printf("Testing layer %d\n", i);

		for (j = 0; j < 4; j++)
			expected_color[j] = Colors[color_index][j] / 255.0f;

		pass = piglit_probe_texel_volume_rgba(GL_TEXTURE_2D_ARRAY, 0,
						      0, 0, i, TEX_SIZE, TEX_SIZE, 1,
						      expected_color) && pass;
	}

	piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}
Example #6
0
static bool
test_format_lifetime(const struct format_desc desc0,
		     const struct format_desc desc1)
{
	GLuint tex, viewTex[3];
	GLint width = 32, w, levels = 6;
	GLint l;
	int bytes;
	unsigned char *buffer0, *buffer1;
	bool pass = true;

	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_1D, tex);
	glTexStorage1D(GL_TEXTURE_1D, levels, desc0.storagefmt, width);
	glGenTextures(3, viewTex);
	glTextureView(viewTex[0], GL_TEXTURE_1D, tex,  desc0.internalfmt, 0,
			  levels, 0, 1);
	glTextureView(viewTex[1], GL_TEXTURE_1D, viewTex[0],
		      desc1.internalfmt, 0, levels, 0, 1);

	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;

	/* load each mipmap with a different color texture */
	w = width;
	bytes = (desc0.red + desc0.green + desc0.blue + desc0.alpha) / 8;
	for (l = 0; l < levels; l++) {
		GLubyte *buf = create_solid_image(width, 1, 1, bytes, l);

		if (buf != NULL) {
			glTexSubImage1D(GL_TEXTURE_1D, l, 0, w, desc0.imagefmt,
						desc0.imagetype, buf);
			free(buf);
		} else {
			piglit_report_result(PIGLIT_FAIL);
			assert(!"create_solid_image() failed\n");
		}

		if (w > 1)
			w /= 2;
	}

#if 0  /* debug */
	printf("fmt0=%s, fmt1=%s, strgfmt0=%s, gettype0=%s\n",
		   piglit_get_gl_enum_name(desc0.internalfmt),
		   piglit_get_gl_enum_name(desc1.internalfmt),
		   piglit_get_gl_enum_name(desc0.storagefmt),
		   piglit_get_gl_enum_name(desc0.gettype));
	printf("bytes=%d, width=%d, viewTex[0]=%d, [1]=%d, [2]=%d\n",bytes,
		   width, viewTex[0], viewTex[1], viewTex[2]);
#endif

	glDeleteTextures(1, &tex);

	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;

	/* compare view0 all level texels bytes to view1 texels bytes */
	buffer0 = malloc(width * bytes);
	buffer1 = malloc(width * bytes);
	w = width;
	for (l = 0; l < levels; l++) {
		glBindTexture(GL_TEXTURE_1D, viewTex[0]);
		glGetTexImage(GL_TEXTURE_1D, l, desc0.getfmt, desc0.gettype,
			      buffer0);

		glBindTexture(GL_TEXTURE_1D, viewTex[1]);
		glGetTexImage(GL_TEXTURE_1D, l, desc1.getfmt, desc1.gettype,
			      buffer1);
		if (buffers_equal(buffer0, buffer1, w)) {
			pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
			printf("level %d texel mismatch view0 and view1, width=%d\n",
			       l, w);
			printf("internal format0 %s, internal format1 %s\n",
			       piglit_get_gl_enum_name(desc0.internalfmt),
			       piglit_get_gl_enum_name(desc1.internalfmt));
			pass = false;
		}

		if (w > 1)
			w /= 2;
	}

	/* compare view1 base level texels to view2 after view0 and view1
	   deleted */
	glBindTexture(GL_TEXTURE_1D, viewTex[1]);
	glGetTexImage(GL_TEXTURE_1D, 0, desc1.getfmt, desc1.gettype, buffer1);

	glTextureView(viewTex[2], GL_TEXTURE_1D, viewTex[0],
		      desc0.internalfmt, 0, 1, 0, 1);
	pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
	glDeleteTextures(2, viewTex);
	glBindTexture(GL_TEXTURE_1D, viewTex[2]);
	glGetTexImage(GL_TEXTURE_1D, 0, desc0.getfmt, desc0.gettype, buffer0);

	if (buffers_equal(buffer0, buffer1, width)) {
		pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
		printf("Mismatched texels view1 and view2\n");
		printf("internal format0 %s, internal format1 %s\n",
			       piglit_get_gl_enum_name(desc0.internalfmt),
			       piglit_get_gl_enum_name(desc1.internalfmt));
		pass = false;
	}

	free(buffer0);
	free(buffer1);
	glDeleteTextures(1, &viewTex[2]);

	return pass;
}