/*
 * Copyright (c) The Piglit project 2007
 *
 * 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
 * on the rights to use, copy, modify, merge, publish, distribute, sub
 * license, 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 NON-INFRINGEMENT.  IN NO EVENT SHALL
 * VA LINUX SYSTEM, IBM AND/OR THEIR SUPPLIERS 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.
 */

#include "piglit-util-gl.h"
#include <ctype.h>

#define BUFFER_OFFSET(i) ((char *)NULL + (i))

/**
 * An array of pointers to extension strings.
 *
 * Each extension is pointed to by a separate entry in the array.
 *
 * The end of the array is indicated by a NULL pointer.
 */
static const char **gl_extensions = NULL;

static const float color_wheel[4][4] = {
	{1, 0, 0, 1}, /* red */
	{0, 1, 0, 1}, /* green */
	{0, 0, 1, 1}, /* blue */
	{1, 1, 1, 1}, /* white */
};

bool piglit_is_core_profile;

bool piglit_is_gles(void)
{
	const char *version_string = (const char *) glGetString(GL_VERSION);
	return strncmp("OpenGL ES", version_string, 9) == 0;
}

bool piglit_is_gles3(void)
{
	const char *version_string = (const char *) glGetString(GL_VERSION);
	return strncmp("OpenGL ES 3", version_string, 11) == 0;
}

int piglit_get_gl_version(void)
{
	const char *version_string = (const char *) glGetString(GL_VERSION);
	int scanf_count;
	int major;
	int minor;

	/* skip to version number */
	while (!isdigit(*version_string) && *version_string != '\0')
		version_string++;

	/* Interpret version number */
	scanf_count = sscanf(version_string, "%i.%i", &major, &minor);
	if (scanf_count != 2) {
		printf("Unable to interpret GL_VERSION string: %s\n",
		       version_string);
		piglit_report_result(PIGLIT_FAIL);
	}
	return 10*major+minor;
}

static const char** gl_extension_array_from_getstring()
{
	const char *gl_extensions_string;
	gl_extensions_string = (const char *) glGetString(GL_EXTENSIONS);
	return piglit_split_string_to_array(gl_extensions_string, " ");
}

static const char** gl_extension_array_from_getstringi()
{
	const char **strings;
	int loop, num_extensions;

	glGetIntegerv(GL_NUM_EXTENSIONS, &num_extensions);
	strings = malloc (sizeof(char*) * (num_extensions + 1));
	assert (strings != NULL);

	for (loop = 0; loop < num_extensions; loop++) {
		strings[loop] = (const char*) glGetStringi(GL_EXTENSIONS, loop);
	}

	strings[loop] = NULL;

	return (const char**) strings;
}

static void initialize_piglit_extension_support(void)
{
	if (gl_extensions != NULL) {
		return;
	}

	if (piglit_get_gl_version() < 30) {
		gl_extensions = gl_extension_array_from_getstring();
	} else {
		gl_extensions = gl_extension_array_from_getstringi();
	}
}

void piglit_gl_invalidate_extensions()
{
	if (gl_extensions != NULL) {
		free(gl_extensions);
		gl_extensions = NULL;
	}
}

bool piglit_is_extension_supported(const char *name)
{
	initialize_piglit_extension_support();
	return piglit_is_extension_in_array(gl_extensions, name);
}

void piglit_require_gl_version(int required_version_times_10)
{
	if (piglit_is_gles() ||
	    piglit_get_gl_version() < required_version_times_10) {
		printf("Test requires GL version %g\n",
		       required_version_times_10 / 10.0);
		piglit_report_result(PIGLIT_SKIP);
	}
}

void piglit_require_extension(const char *name)
{
	if (!piglit_is_extension_supported(name)) {
		printf("Test requires %s\n", name);
		piglit_report_result(PIGLIT_SKIP);
	}
}

void piglit_require_not_extension(const char *name)
{
	if (piglit_is_extension_supported(name)) {
		piglit_report_result(PIGLIT_SKIP);
	}
}

void piglit_require_draw_buffers(int count)
{
	GLint max_targets;
	glGetIntegerv(GL_MAX_DRAW_BUFFERS, &max_targets);
	if (max_targets < 2) {
		printf("Test requires GL_MAX_DRAW_BUFFERS >= %d\n", count);
		piglit_report_result(PIGLIT_SKIP);
	}
}

const char* piglit_get_gl_error_name(GLenum error)
{
#define CASE(x) case x: return #x; 
    switch (error) {
    CASE(GL_INVALID_ENUM)
    CASE(GL_INVALID_OPERATION)
    CASE(GL_INVALID_VALUE)
    CASE(GL_NO_ERROR)
    CASE(GL_OUT_OF_MEMORY)
    CASE(GL_STACK_OVERFLOW)
    CASE(GL_STACK_UNDERFLOW)
    CASE(GL_INVALID_FRAMEBUFFER_OPERATION)
    default:
        return "(unrecognized error)";
    }
#undef CASE
}

GLboolean
piglit_check_gl_error_(GLenum expected_error, const char *file, unsigned line)
{
	GLenum actual_error;

	actual_error = glGetError();
	if (actual_error == expected_error) {
		return GL_TRUE;
	}

	/*
	 * If the lookup of the error's name is successful, then print
	 *     Unexpected GL error: NAME 0xHEX
	 * Else, print
	 *     Unexpected GL error: 0xHEX
	 */
	printf("Unexpected GL error: %s 0x%x\n",
               piglit_get_gl_error_name(actual_error), actual_error);
        printf("(Error at %s:%u)\n", file, line);

	/* Print the expected error, but only if an error was really expected. */
	if (expected_error != GL_NO_ERROR) {
		printf("Expected GL error: %s 0x%x\n",
		piglit_get_gl_error_name(expected_error), expected_error);
        }

	return GL_FALSE;
}

void piglit_reset_gl_error(void)
{
	while (glGetError() != GL_NO_ERROR) {
		/* empty */
	}
}

/* These texture coordinates should have 1 or -1 in the major axis selecting
 * the face, and a nearly-1-or-negative-1 value in the other two coordinates
 * which will be used to produce the s,t values used to sample that face's
 * image.
 */
GLfloat cube_face_texcoords[6][4][3] = {
	{ /* GL_TEXTURE_CUBE_MAP_POSITIVE_X */
		{1.0,  0.99,  0.99},
		{1.0,  0.99, -0.99},
		{1.0, -0.99, -0.99},
		{1.0, -0.99,  0.99},
	},
	{ /* GL_TEXTURE_CUBE_MAP_NEGATIVE_X */
		{-1.0,  0.99, -0.99},
		{-1.0,  0.99,  0.99},
		{-1.0, -0.99,  0.99},
		{-1.0, -0.99, -0.99},
	},
	{ /* GL_TEXTURE_CUBE_MAP_POSITIVE_Y */
		{-0.99, 1.0, -0.99},
		{ 0.99, 1.0, -0.99},
		{ 0.99, 1.0,  0.99},
		{-0.99, 1.0,  0.99},
	},
	{ /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Y */
		{-0.99, -1.0,  0.99},
		{-0.99, -1.0, -0.99},
		{ 0.99, -1.0, -0.99},
		{ 0.99, -1.0,  0.99},
	},
	{ /* GL_TEXTURE_CUBE_MAP_POSITIVE_Z */
		{-0.99,  0.99, 1.0},
		{-0.99, -0.99, 1.0},
		{ 0.99, -0.99, 1.0},
		{ 0.99,  0.99, 1.0},
	},
	{ /* GL_TEXTURE_CUBE_MAP_NEGATIVE_Z */
		{ 0.99,  0.99, -1.0},
		{-0.99,  0.99, -1.0},
		{-0.99, -0.99, -1.0},
		{ 0.99, -0.99, -1.0},
	},
};

const char *cube_face_names[6] = {
	"POSITIVE_X",
	"NEGATIVE_X",
	"POSITIVE_Y",
	"NEGATIVE_Y",
	"POSITIVE_Z",
	"NEGATIVE_Z",
};

const GLenum cube_face_targets[6] = {
	GL_TEXTURE_CUBE_MAP_POSITIVE_X,
	GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
	GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
	GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
	GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
	GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
};

float piglit_tolerance[4] = { 0.01, 0.01, 0.01, 0.01 };

void
piglit_set_tolerance_for_bits(int rbits, int gbits, int bbits, int abits)
{
	int bits[4] = {rbits, gbits, bbits, abits};
	int i;

	for (i = 0; i < 4; i++) {
		if (bits[i] == 0) {
			/* With 0 bits of storage, we still want to
			 * validate expected results, (such as
			 * alpha==1.0 when targeting storage with no
			 * alpha bits). */
			piglit_tolerance[i] = 3.0 / (1 << 8);
		} else if (bits[i] == 1) {
			/* Don't try to validate channels when there's only 1
			 * bit of precision.
			 */
			piglit_tolerance[i] = 1.0;
		} else {
			piglit_tolerance[i] = 3.0 / (1 << bits[i]);
		}
	}
}

typedef union { GLfloat f; GLint i; } fi_type;

/**
 * Convert a 4-byte float to a 2-byte half float.
 * Based on code from:
 * http://www.opengl.org/discussion_boards/ubb/Forum3/HTML/008786.html
 *
 * Taken over from Mesa.
 */
unsigned short
piglit_half_from_float(float val)
{
	const fi_type fi = {val};
	const int flt_m = fi.i & 0x7fffff;
	const int flt_e = (fi.i >> 23) & 0xff;
	const int flt_s = (fi.i >> 31) & 0x1;
	int s, e, m = 0;
	unsigned short result;

	/* sign bit */
	s = flt_s;

	/* handle special cases */
	if ((flt_e == 0) && (flt_m == 0)) {
		/* zero */
		/* m = 0; - already set */
		e = 0;
	}
	else if ((flt_e == 0) && (flt_m != 0)) {
		/* denorm -- denorm float maps to 0 half */
		/* m = 0; - already set */
		e = 0;
	}
	else if ((flt_e == 0xff) && (flt_m == 0)) {
		/* infinity */
		/* m = 0; - already set */
		e = 31;
	}
	else if ((flt_e == 0xff) && (flt_m != 0)) {
		/* NaN */
		m = 1;
		e = 31;
	}
	else {
		/* regular number */
		const int new_exp = flt_e - 127;
		if (new_exp < -24) {
			/* this maps to 0 */
			/* m = 0; - already set */
			e = 0;
		}
		else if (new_exp < -14) {
			/* this maps to a denorm */
			/* 2^-exp_val*/
			unsigned int exp_val = (unsigned int) (-14 - new_exp);

			e = 0;
			switch (exp_val) {
			case 0:
				/* m = 0; - already set */
				break;
			case 1: m = 512 + (flt_m >> 14); break;
			case 2: m = 256 + (flt_m >> 15); break;
			case 3: m = 128 + (flt_m >> 16); break;
			case 4: m = 64 + (flt_m >> 17); break;
			case 5: m = 32 + (flt_m >> 18); break;
			case 6: m = 16 + (flt_m >> 19); break;
			case 7: m = 8 + (flt_m >> 20); break;
			case 8: m = 4 + (flt_m >> 21); break;
			case 9: m = 2 + (flt_m >> 22); break;
			case 10: m = 1; break;
			}
		}
		else if (new_exp > 15) {
			/* map this value to infinity */
			/* m = 0; - already set */
			e = 31;
		}
		else {
			/* regular */
			e = new_exp + 15;
			m = flt_m >> 13;
		}
	}

	result = (s << 15) | (e << 10) | m;
	return result;
}


/**
 * Return block size info for a specific texture compression format.
 * \param  bw returns the block width, in pixels
 * \param  bh returns the block height, in pixels
 * \param  return number of bytes per block
 * \return true if format is a known compressed format, false otherwise
 */
bool
piglit_get_compressed_block_size(GLenum format,
				 unsigned *bw, unsigned *bh, unsigned *bytes)
{
	switch (format) {
	case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
		*bw = *bh = 4;
		*bytes = 8;
		return true;
	case GL_COMPRESSED_SRGB_S3TC_DXT1_EXT:
	case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT:
	case GL_COMPRESSED_RED:
	case GL_COMPRESSED_RED_RGTC1:
	case GL_COMPRESSED_SIGNED_RED_RGTC1:
	case GL_COMPRESSED_LUMINANCE_LATC1_EXT:
	case GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT:
	case GL_COMPRESSED_RGB8_ETC2:
	case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2:
	case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2:
	case GL_COMPRESSED_R11_EAC:
	case GL_COMPRESSED_SIGNED_R11_EAC:
	case GL_COMPRESSED_SRGB8_ETC2:
		*bw = *bh = 4;
		*bytes = 8;
		return true;
	case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
	case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
	case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT:
	case GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT:
	case GL_COMPRESSED_RG:
	case GL_COMPRESSED_RG_RGTC2:
	case GL_COMPRESSED_SIGNED_RG_RGTC2:
	case GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT:
	case GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT:
	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:
	case GL_COMPRESSED_RGBA8_ETC2_EAC:
	case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC:
	case GL_COMPRESSED_RG11_EAC:
	case GL_COMPRESSED_SIGNED_RG11_EAC:
		*bw = *bh = 4;
		*bytes = 16;
		return true;
	case GL_COMPRESSED_RGB_FXT1_3DFX:
	case GL_COMPRESSED_RGBA_FXT1_3DFX:
		*bw = 8;
		*bh = 4;
		*bytes = 16;
		return true;
	default:
		/* return something rather than uninitialized values */
		*bw = *bh = *bytes = 1;
		return false;
	}
}


/**
 * Compute size (in bytes) needed to store an image in the given compressed
 * format.
 */
unsigned
piglit_compressed_image_size(GLenum format, unsigned width, unsigned height)
{
	unsigned bw, bh, bytes;
	bool b = piglit_get_compressed_block_size(format, &bw, &bh, &bytes);

	(void)b;
	assert(b);
	return ((width + bw - 1) / bw) * ((height + bh - 1) / bh) * bytes;
}


/**
 * Return offset (in bytes) to the given texel in a compressed image.
 * Note the x and y must be multiples of the compressed block size.
 */
unsigned
piglit_compressed_pixel_offset(GLenum format, unsigned width,
			       unsigned x, unsigned y)
{
	unsigned bw, bh, bytes, offset;
	bool b = piglit_get_compressed_block_size(format, &bw, &bh, &bytes);

	(void)b;
	assert(b);

	assert(x % bw == 0);
	assert(y % bh == 0);
	assert(width % bw == 0);

	offset = (width / bw * bytes * y / bh) + (x / bw * bytes);

	return offset;
}

void
piglit_escape_exit_key(unsigned char key, int x, int y)
{
	(void) x;
	(void) y;
	switch (key) {
		case 27:
			exit(0);
			break;
	}
	if (!piglit_is_gles())
		piglit_post_redisplay();
}

/**
 * Convenience function to configure an abitrary orthogonal projection matrix
 */
void
piglit_gen_ortho_projection(double left, double right, double bottom,
			    double top, double near_val, double far_val,
			    GLboolean push)
{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if (push)
		glPushMatrix();

	if (piglit_is_gles())
		glOrthof(left, right, bottom, top, near_val, far_val);
	else
		glOrtho(left, right, bottom, top, near_val, far_val);

	glMatrixMode(GL_MODELVIEW);
	if (push)
		glPushMatrix();
	glLoadIdentity();
}

/**
 * Convenience function to configure projection matrix for window coordinates
 */
void
piglit_ortho_projection(int w, int h, GLboolean push)
{
        /* Set up projection matrix so we can just draw using window
         * coordinates.
         */
	piglit_gen_ortho_projection(0, w, 0, h, -1, 1, push);
}

/**
 * Convenience function to configure frustum projection.
 */
void
piglit_frustum_projection(GLboolean push, double l, double r, double b,
			  double t, double n, double f)
{
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	if (push)
		glPushMatrix();

	if (piglit_is_gles())
		glFrustumf(l, r, b, t, n, f);
	else
		glFrustum(l, r, b, t, n, f);

	glMatrixMode(GL_MODELVIEW);
	if (push)
		glPushMatrix();
	glLoadIdentity();
}

/**
 * Convenience function to configure a shader uniform variable as an
 * arbitrary orthogonal projection matrix.
 */
void
piglit_gen_ortho_uniform(GLint location, double l, double r, double b,
			 double t, double n, double f)
{
	const GLfloat values[4][4] = {
		{ 2/(r-l),      0,            0,            0 },
		{    0,         2/(t-b),      0,            0 },
		{    0,         0,            -2/(f-n),     0 },
		{ -(r+l)/(r-l), -(t+b)/(t-b), -(f+n)/(f-n), 1 }
	};
	glUniformMatrix4fv(location, 1, GL_FALSE, (const GLfloat *)values);
}


/**
 * Convenience function to configure a shader uniform variable as a
 * projection matrix for window coordinates.
 */
void
piglit_ortho_uniform(GLint location, int w, int h)
{
        /* Set up projection matrix so we can just draw using window
         * coordinates.
         */
	piglit_gen_ortho_uniform(location, 0, w, 0, h, -1, 1);
}


unsigned
required_gl_version_from_glsl_version(unsigned glsl_version)
{
	switch (glsl_version) {
	case 110: return 20;
	case 120: return 21;
	/* GLSL 1.30 is naturally matched with GL3,
	 * but is usefully supportable on GL2.1 if
	 * EXT_gpu_shader4 is also supported.
	 */
	case 130: return 21;
	case 140: return 31;
	case 150: return 32;
	case 330: return 33;
	case 400: return 40;
	case 410: return 41;
	case 420: return 42;
	case 430: return 43;
	case 440: return 44;
	case 450: return 45;
	case 460: return 46;
	default: return 0;
	}
}

/**
 * Call glDrawArrays.  verts is expected to be
 *
 *   float verts[4][4];
 *
 * if not NULL; tex is expected to be
 *
 *   float tex[4][2];
 *
 * if not NULL.
 */
void
piglit_draw_rect_from_arrays(const void *verts, const void *tex,
			     bool use_patches, unsigned instance_count)
{
	bool use_fixed_function_attributes;

	bool gles = piglit_is_gles();
	int version = piglit_get_gl_version();

	if (gles) {
		use_fixed_function_attributes = (version < 20);
	}  else if (version >= 20 ||
		    piglit_is_extension_supported("GL_ARB_shader_objects")) {
		GLuint prog;

		glGetIntegerv(GL_CURRENT_PROGRAM, (GLint *) &prog);

		if (!prog &&
		    piglit_is_extension_supported("GL_ARB_separate_shader_objects")) {
			GLuint pipeline;

			glGetIntegerv(GL_PROGRAM_PIPELINE_BINDING,
				      (GLint*)&pipeline);
			if (pipeline)
				glGetProgramPipelineiv(pipeline, GL_VERTEX_SHADER,
						       (GLint*)&prog);
		}

		/* If there is a current program and that program has an
		 * active attribute named piglit_vertex, don't use the fixed
		 * function inputs. Never use fixed function inputs on core
		 * profile.
		 */
		use_fixed_function_attributes = ((prog == 0)
			|| glGetAttribLocation(prog, "piglit_vertex") == -1)
			&& !piglit_is_core_profile;
	} else {
		use_fixed_function_attributes = true;
	}

	if (use_fixed_function_attributes) {
		if (verts) {
			glVertexPointer(4, GL_FLOAT, 0, verts);
			glEnableClientState(GL_VERTEX_ARRAY);
		}

		if (tex) {
			glTexCoordPointer(2, GL_FLOAT, 0, tex);
			glEnableClientState(GL_TEXTURE_COORD_ARRAY);
		}

		if (use_patches) {
			GLint old_patch_vertices;

			glGetIntegerv(GL_PATCH_VERTICES, &old_patch_vertices);
			glPatchParameteri(GL_PATCH_VERTICES, 4);
			if (instance_count > 1)
				glDrawArraysInstanced(GL_PATCHES, 0, 4, instance_count);
			else
				glDrawArrays(GL_PATCHES, 0, 4);
			glPatchParameteri(GL_PATCH_VERTICES, old_patch_vertices);
		} else {
			if (instance_count > 1)
				glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, instance_count);
			else
				glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
		}

		if (verts)
			glDisableClientState(GL_VERTEX_ARRAY);
		if (tex)
			glDisableClientState(GL_TEXTURE_COORD_ARRAY);
	} else {
		GLuint buf = 0;
		GLuint old_buf = 0;
		GLuint vao = 0;
		GLuint old_vao = 0;

		/* Vertex array objects were added in both OpenGL 3.0 and
		 * OpenGL ES 3.0.  The use of VAOs is required in desktop
		 * OpenGL 3.1 (without GL_ARB_compatibility) and all desktop
		 * OpenGL core profiles.  If the functionality is supported,
		 * just use it.
		 */
		if (piglit_get_gl_version() >= 30
		    || piglit_is_extension_supported("GL_OES_vertex_array_object")
		    || piglit_is_extension_supported("GL_ARB_vertex_array_object")) {
			glGetIntegerv(GL_VERTEX_ARRAY_BINDING,
				      (GLint *) &old_vao);
			glGenVertexArrays(1, &vao);
			glBindVertexArray(vao);
		}

		/* Assume that VBOs are supported in any implementation that
		 * uses shaders.
		 */
		glGetIntegerv(GL_ARRAY_BUFFER_BINDING,
			      (GLint *) &old_buf);
		glGenBuffers(1, &buf);
		glBindBuffer(GL_ARRAY_BUFFER, buf);
		glBufferData(GL_ARRAY_BUFFER,
			     (sizeof(GLfloat) * 4 * 4)
			     + (sizeof(GLfloat) * 4 * 2),
			     NULL,
			     GL_STATIC_DRAW);

		if (verts) {
			glBufferSubData(GL_ARRAY_BUFFER,
					0,
					sizeof(GLfloat) * 4 * 4,
					verts);
			glVertexAttribPointer(PIGLIT_ATTRIB_POS, 4, GL_FLOAT,
					      GL_FALSE, 0,
					      BUFFER_OFFSET(0));
			glEnableVertexAttribArray(PIGLIT_ATTRIB_POS);
		}

		if (tex) {
			glBufferSubData(GL_ARRAY_BUFFER,
					sizeof(GLfloat) * 4 * 4,
					sizeof(GLfloat) * 4 * 2,
					tex);
			glVertexAttribPointer(PIGLIT_ATTRIB_TEX, 2, GL_FLOAT,
					      GL_FALSE, 0,
					      BUFFER_OFFSET(sizeof(GLfloat) * 4 * 4));
			glEnableVertexAttribArray(PIGLIT_ATTRIB_TEX);
		}

		if (use_patches) {
			GLint old_patch_vertices;

			glGetIntegerv(GL_PATCH_VERTICES, &old_patch_vertices);
			glPatchParameteri(GL_PATCH_VERTICES, 4);
			if (instance_count > 1)
				glDrawArraysInstanced(GL_PATCHES, 0, 4, instance_count);
			else
				glDrawArrays(GL_PATCHES, 0, 4);
			glPatchParameteri(GL_PATCH_VERTICES, old_patch_vertices);
		}
		else {
			if (instance_count > 1)
				glDrawArraysInstanced(GL_TRIANGLE_STRIP, 0, 4, instance_count);
			else
				glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
		}

		if (verts)
			glDisableVertexAttribArray(PIGLIT_ATTRIB_POS);
		if (tex)
			glDisableVertexAttribArray(PIGLIT_ATTRIB_TEX);

		glBindBuffer(GL_ARRAY_BUFFER, old_buf);
		glDeleteBuffers(1, &buf);

		if (vao != 0) {
			glBindVertexArray(old_vao);
			glDeleteVertexArrays(1, &vao);
		}
	}
}

/**
 * Convenience function to draw an axis-aligned rectangle.
 */
GLvoid
piglit_draw_rect_custom(float x, float y, float w, float h, bool use_patches,
			unsigned instance_count)
{
	float verts[4][4];

	verts[0][0] = x;
	verts[0][1] = y;
	verts[0][2] = 0.0;
	verts[0][3] = 1.0;
	verts[1][0] = x + w;
	verts[1][1] = y;
	verts[1][2] = 0.0;
	verts[1][3] = 1.0;
	verts[2][0] = x;
	verts[2][1] = y + h;
	verts[2][2] = 0.0;
	verts[2][3] = 1.0;
	verts[3][0] = x + w;
	verts[3][1] = y + h;
	verts[3][2] = 0.0;
	verts[3][3] = 1.0;

	piglit_draw_rect_from_arrays(verts, NULL, use_patches, instance_count);
}

/**
 * Convenience function to draw an axis-aligned rectangle.
 */
GLvoid
piglit_draw_rect(float x, float y, float w, float h)
{
	piglit_draw_rect_custom(x, y, w, h, false, 1);
}

/**
 * Convenience function to draw an axis-aligned rectangle.
 */
GLvoid
piglit_draw_rect_z(float z, float x, float y, float w, float h)
{
	float verts[4][4];

	verts[0][0] = x;
	verts[0][1] = y;
	verts[0][2] = z;
	verts[0][3] = 1.0;
	verts[1][0] = x + w;
	verts[1][1] = y;
	verts[1][2] = z;
	verts[1][3] = 1.0;
	verts[2][0] = x;
	verts[2][1] = y + h;
	verts[2][2] = z;
	verts[2][3] = 1.0;
	verts[3][0] = x + w;
	verts[3][1] = y + h;
	verts[3][2] = z;
	verts[3][3] = 1.0;

	piglit_draw_rect_from_arrays(verts, NULL, false, 1);
}

/**
 * Convenience function to draw an axis-aligned rectangle
 * with texture coordinates.
 */
GLvoid
piglit_draw_rect_tex(float x, float y, float w, float h,
                     float tx, float ty, float tw, float th)
{
	float verts[4][4];
	float tex[4][2];

	verts[0][0] = x;
	verts[0][1] = y;
	verts[0][2] = 0.0;
	verts[0][3] = 1.0;
	tex[0][0] = tx;
	tex[0][1] = ty;
	verts[1][0] = x + w;
	verts[1][1] = y;
	verts[1][2] = 0.0;
	verts[1][3] = 1.0;
	tex[1][0] = tx + tw;
	tex[1][1] = ty;
	verts[2][0] = x;
	verts[2][1] = y + h;
	verts[2][2] = 0.0;
	verts[2][3] = 1.0;
	tex[2][0] = tx;
	tex[2][1] = ty + th;
	verts[3][0] = x + w;
	verts[3][1] = y + h;
	verts[3][2] = 0.0;
	verts[3][3] = 1.0;
	tex[3][0] = tx + tw;
	tex[3][1] = ty + th;

	piglit_draw_rect_from_arrays(verts, tex, false, 1);
}

unsigned
piglit_num_components(GLenum format)
{
	switch (format) {
	case GL_ALPHA:
	case GL_DEPTH_COMPONENT:
	case GL_INTENSITY:
	case GL_LUMINANCE:
	case GL_RED:
	case GL_GREEN:
	case GL_BLUE:
		return 1;
	case GL_DEPTH_STENCIL:
	case GL_LUMINANCE_ALPHA:
	case GL_RG:
		return 2;
	case GL_RGB:
	case GL_BGR:
		return 3;
	case GL_RGBA:
	case GL_BGRA:
	case GL_ABGR_EXT:
		return 4;
	default:
		printf("Unknown num_components for %s\n",
		       piglit_get_gl_enum_name(format));
		piglit_report_result(PIGLIT_FAIL);
		return 0;
	}
}

/* This function only handles formats not supported by the OpenGL framebuffer
 * size queries, which only support querying the R,G,B,A sizes.
 *
 * The function doesn't change the bits for formats it doesn't handle.
 *
 * The returned number of bits is an approximation but should be no less than
 * the actual number of bits for the format chosen by OpenGL.
 *
 * The combination of the OpenGL framebuffer queries size and calling
 * this function without checking the return value should give you reasonable
 * values for any format.
 */
bool
piglit_get_luminance_intensity_bits(GLenum internalformat, int *bits)
{
	switch (internalformat) {
	case GL_LUMINANCE4:
		bits[0] = bits[1] = bits[2] = 4;
		bits[3] = 0;
		return true;

	case GL_LUMINANCE:
	case GL_LUMINANCE_SNORM:
	case GL_LUMINANCE8:
	case GL_LUMINANCE8_SNORM:
	case GL_LUMINANCE8I_EXT:
	case GL_LUMINANCE8UI_EXT:
		bits[0] = bits[1] = bits[2] = 8;
		bits[3] = 0;
		return true;

	case GL_LUMINANCE12:
		bits[0] = bits[1] = bits[2] = 12;
		bits[3] = 0;
		return true;

	case GL_LUMINANCE16:
	case GL_LUMINANCE16_SNORM:
	case GL_LUMINANCE16I_EXT:
	case GL_LUMINANCE16UI_EXT:
	case GL_LUMINANCE16F_ARB:
		bits[0] = bits[1] = bits[2] = 16;
		bits[3] = 0;
		return true;

	case GL_LUMINANCE32I_EXT:
	case GL_LUMINANCE32UI_EXT:
	case GL_LUMINANCE32F_ARB:
		bits[0] = bits[1] = bits[2] = 32;
		bits[3] = 0;
		return true;

	case GL_LUMINANCE4_ALPHA4:
	case GL_INTENSITY4:
		bits[0] = bits[1] = bits[2] = bits[3] = 4;
		return true;

	case GL_LUMINANCE_ALPHA:
	case GL_LUMINANCE_ALPHA_SNORM:
	case GL_LUMINANCE8_ALPHA8:
	case GL_LUMINANCE8_ALPHA8_SNORM:
	case GL_LUMINANCE_ALPHA8I_EXT:
	case GL_LUMINANCE_ALPHA8UI_EXT:
	case GL_INTENSITY:
	case GL_INTENSITY_SNORM:
	case GL_INTENSITY8:
	case GL_INTENSITY8_SNORM:
	case GL_INTENSITY8I_EXT:
	case GL_INTENSITY8UI_EXT:
		bits[0] = bits[1] = bits[2] = bits[3] = 8;
		return true;

	case GL_LUMINANCE12_ALPHA12:
	case GL_INTENSITY12:
		bits[0] = bits[1] = bits[2] = bits[3] = 12;
		return true;

	case GL_LUMINANCE16_ALPHA16:
	case GL_LUMINANCE16_ALPHA16_SNORM:
	case GL_LUMINANCE_ALPHA16I_EXT:
	case GL_LUMINANCE_ALPHA16UI_EXT:
	case GL_LUMINANCE_ALPHA16F_ARB:
	case GL_INTENSITY16:
	case GL_INTENSITY16_SNORM:
	case GL_INTENSITY16I_EXT:
	case GL_INTENSITY16UI_EXT:
	case GL_INTENSITY16F_ARB:
		bits[0] = bits[1] = bits[2] = bits[3] = 16;
		return true;

	case GL_LUMINANCE_ALPHA32I_EXT:
	case GL_LUMINANCE_ALPHA32UI_EXT:
	case GL_LUMINANCE_ALPHA32F_ARB:
	case GL_INTENSITY32I_EXT:
	case GL_INTENSITY32UI_EXT:
	case GL_INTENSITY32F_ARB:
		bits[0] = bits[1] = bits[2] = bits[3] = 32;
		return true;
	}
	return false;
}

/* Wrapper around glReadPixels that always returns floats; reads and converts
 * GL_UNSIGNED_BYTE on GLES.  If pixels == NULL, malloc a float array of the
 * appropriate size, otherwise use the one provided. */
GLfloat *
piglit_read_pixels_float(GLint x, GLint y, GLsizei width, GLsizei height,
		  	 GLenum format, GLfloat *pixels)
{
	GLubyte *pixels_b;
	unsigned i, j, k;
	int comps = piglit_num_components(format);

	if (!pixels)
		pixels = malloc(width * height * comps * sizeof(GLfloat));

	if (!piglit_is_gles()) {
		glReadPixels(x, y, width, height, format, GL_FLOAT, pixels);
		return pixels;
	}

	pixels_b = malloc(width * height * 4 * sizeof(GLubyte));
	glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels_b);
	k = 0;
	for (i = 0; i < width * height; i++) {
		for (j = 0; j < comps; j++) {
			pixels[k++] = pixels_b[i*4+j] / 255.0f;
		}
	}
	free(pixels_b);
	return pixels;
}

static bool
can_probe_ubyte()
{
	int r,g,b,a,read;

	if (!piglit_is_extension_supported("GL_ARB_framebuffer_object"))
		return false;

	glGetIntegerv(GL_READ_BUFFER, &read);
	if (read == GL_FRONT)
		read = GL_FRONT_LEFT;
	if (read == GL_BACK)
		read = GL_BACK_LEFT;

	glGetFramebufferAttachmentParameteriv(GL_READ_FRAMEBUFFER, read,
					      GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, &r);
	glGetFramebufferAttachmentParameteriv(GL_READ_FRAMEBUFFER, read,
					      GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE, &g);
	glGetFramebufferAttachmentParameteriv(GL_READ_FRAMEBUFFER, read,
					      GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE, &b);
	glGetFramebufferAttachmentParameteriv(GL_READ_FRAMEBUFFER, read,
					      GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, &a);

	/* it could be LUMINANCE32F, etc. */
	if (!r && !g && !b && !a)
		return false;

	return r <= 8 && g <= 8 && b <= 8 && a <= 8;
}

static void
print_components_ubyte(const GLubyte *pixel, unsigned components)
{
	int p;
	for (p = 0; p < components; ++p)
		printf(" %u", pixel[p]);
}

static void
print_components_float(const float *pixel, unsigned components)
{
	int p;
	for (p = 0; p < components; ++p)
		printf(" %f", pixel[p]);
}

static void
print_bad_pixel_ubyte(int x, int y, int num_components,
		      const GLubyte *expected, const GLubyte *observed)
{
	printf("Probe color at (%i,%i)\n", x, y);
	printf("  Expected:");
	print_components_ubyte(expected, num_components);
	printf("\n  Observed:");
	print_components_ubyte(observed, num_components);
	printf("\n");
}

static void
print_bad_pixel_float(int x, int y, int num_components,
		      const float *expected, const float *observed)
{
	printf("Probe color at (%i,%i)\n", x, y);
	printf("  Expected:");
	print_components_float(expected, num_components);
	printf("\n  Observed:");
	print_components_float(observed, num_components);
	printf("\n");
}

static bool
compare_pixels_ubyte(const GLubyte *color1, const GLubyte *color2,
		     const GLubyte *tolerance, int components)
{
	for (int p = 0; p < components; ++p)
		if (abs((int)color1[p] - (int)color2[p]) > tolerance[p])
			return false;
	return true;
}

bool
piglit_compare_pixels_float(const float *color1, const float *color2,
		     const float *tolerance, int components)
{
	for (int p = 0; p < components; ++p)
		if (fabsf(color1[p] - color2[p]) > tolerance[p])
			return false;
	return true;
}

int
piglit_probe_pixel_rgb_silent(int x, int y, const float* expected, float *out_probe)
{
	GLfloat probe[3];

	piglit_read_pixels_float(x, y, 1, 1, GL_RGB, probe);

	bool pass =
		piglit_compare_pixels_float(probe, expected, piglit_tolerance, 3);

	if (out_probe)
		memcpy(out_probe, probe, sizeof(probe));

	return pass;
}

int
piglit_probe_pixel_rgba_silent(int x, int y, const float* expected, float *out_probe)
{
	GLfloat probe[4];

	piglit_read_pixels_float(x, y, 1, 1, GL_RGBA, probe);

	bool pass =
		piglit_compare_pixels_float(probe, expected, piglit_tolerance, 4);

	if (out_probe)
		memcpy(out_probe, probe, sizeof(probe));

	return pass;
}

/**
 * Read a pixel from the given location and compare its RGB value to the
 * given expected values.
 *
 * Print a log message if the color value deviates from the expected value.
 * \return true if the color values match, false otherwise
 */
int
piglit_probe_pixel_rgb(int x, int y, const float* expected)
{
	GLfloat probe[3];

	piglit_read_pixels_float(x, y, 1, 1, GL_RGB, probe);

	if (piglit_compare_pixels_float(probe, expected, piglit_tolerance, 3))
		return 1;

	print_bad_pixel_float(x, y, 3, expected, probe);

	return 0;
}

/**
 * Read a pixel from the given location and compare its RGBA value to the
 * given expected values.
 *
 * Print a log message if the color value deviates from the expected value.
 * \return true if the color values match, false otherwise
 */
int
piglit_probe_pixel_rgba(int x, int y, const float* expected)
{
	GLfloat probe[4];

	piglit_read_pixels_float(x, y, 1, 1, GL_RGBA, probe);

	if (piglit_compare_pixels_float(probe, expected, piglit_tolerance, 4))
		return 1;

	print_bad_pixel_float(x, y, 4, expected, probe);

	return 0;
}

static void
array_float_to_ubyte(int n, const float *f, GLubyte *b)
{
	int i;

	for (i = 0; i < n; i++)
		b[i] = f[i] * 255;
}

static void
array_float_to_ubyte_roundup(int n, const float *f, GLubyte *b)
{
	int i;

	for (i = 0; i < n; i++)
		b[i] = ceil(f[i] * 255);
}

static bool
probe_rect_ubyte(int x, int y, int w, int h, int num_components,
		 const float *fexpected, size_t x_pitch, size_t y_pitch,
		 bool silent)
{
	int i, j;
	GLubyte *probe;
	GLubyte *pixels;
	GLubyte tolerance[4];
	GLubyte expected[4];

	array_float_to_ubyte_roundup(num_components, piglit_tolerance,
				     tolerance);
	if (x_pitch == 0 && y_pitch == 0)
		array_float_to_ubyte(num_components, fexpected, expected);

	/* RGBA readbacks are likely to be faster */
	pixels = malloc(w*h*4);
	glReadPixels(x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			probe = &pixels[(j*w+i)*4];

			if (x_pitch != 0 || y_pitch != 0) {
				const float *pexp = fexpected + i * x_pitch +
								j * y_pitch;
				array_float_to_ubyte(num_components,
						     pexp, expected);
			}

			if (compare_pixels_ubyte(probe, expected, tolerance,
						 num_components))
				continue;

			if (!silent) {
				print_bad_pixel_ubyte(
					x + i, y + j, num_components,
					expected, probe);
			}
			free(pixels);
			return false;
		}
	}

	free(pixels);
	return true;
}

static bool
probe_rect_float(int x, int y, int w, int h, int num_components,
		 const float *fexpected, size_t x_pitch, size_t y_pitch,
		 bool silent)
{
	float *pixels = piglit_read_pixels_float(x, y, w, h, GL_RGBA, NULL);

	for (int j = 0; j < h; j++) {
		for (int i = 0; i < w; i++) {
			float *probe = &pixels[(j*w+i)*4];
			const float *pexp = fexpected + i * x_pitch +
							j * y_pitch;

			if (piglit_compare_pixels_float(probe, pexp,
						 piglit_tolerance,
						 num_components))
				continue;

			if (!silent) {
				print_bad_pixel_float(x + i, y + j,
						      num_components,
						      fexpected, probe);
			}
			free(pixels);
			return false;
		}
	}

	free(pixels);
	return true;
}

static bool
probe_rect(int x, int y, int w, int h, int num_components,
	   const float *fexpected, size_t x_pitch, size_t y_pitch,
	   bool silent)
{
	if (can_probe_ubyte()) {
		return probe_rect_ubyte(x, y, w, h, num_components, fexpected,
					x_pitch, y_pitch, silent);
	} else {
		return probe_rect_float(x, y, w, h, num_components, fexpected,
					x_pitch, y_pitch, silent);
	}
}


int
piglit_probe_rect_rgb_silent(int x, int y, int w, int h, const float *expected)
{
	return probe_rect(x, y, w, h, 3, expected, 0, 0, true);
}

/* More efficient variant if you don't know need floats and GBA channels. */
int
piglit_probe_rect_r_ubyte(int x, int y, int w, int h, GLubyte expected)
{
	int i, j, w_aligned;
	GLubyte *pixels;
	GLubyte tolerance = ceil(piglit_tolerance[0] * 255);

	w_aligned = ALIGN(w, 4);
	pixels = malloc(w_aligned * h);

	glReadPixels(x, y, w, h, GL_RED, GL_UNSIGNED_BYTE, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			GLubyte probe = pixels[j*w_aligned+i];

			if (abs((int)probe - (int)expected) >= tolerance) {
				print_bad_pixel_ubyte(x + i, y + j, 1,
						      &expected, &probe);

				free(pixels);
				return 0;
			}
		}
	}

	free(pixels);
	return 1;
}

int
piglit_probe_rect_rgb(int x, int y, int w, int h, const float *expected)
{
	return probe_rect(x, y, w, h, 3, expected, 0, 0, false);
}

int
piglit_probe_rects_equal(int x1, int y1, int x2, int y2,
			int w, int h, GLenum format)
{
	int retval;
	int ncomponents;

	/* Allocate buffer large enough for two rectangles */
	ncomponents = piglit_num_components(format);

	/* Load the pixels into the buffer and compare */
	/* We only need to do one glReadPixels if the images are adjacent */
	if ((x1 + w) == x2 && y1 == y2) {
		float *pixels =
			piglit_read_pixels_float(x1, y1, 2 * w, h, format, NULL);
		retval = piglit_compare_image_halves_color(2*w, h,
						       ncomponents,
						       piglit_tolerance,
						       pixels);
		free(pixels);
	} else {
		float *pixels1 =
			piglit_read_pixels_float(x1, y1, w, h, format, NULL);
		float *pixels2 =
			piglit_read_pixels_float(x2, y2, w, h, format, NULL);
		retval = piglit_compare_images_color(0, 0, w, h,
					       ncomponents,
					       piglit_tolerance,
					       pixels1, pixels2);
		free(pixels1);
		free(pixels2);
	}

	return retval;
}

int
piglit_probe_rect_halves_equal_rgba(int x, int y, int w, int h)
{
	int i, j, p;
	GLfloat probe1[4];
	GLfloat probe2[4];
	GLubyte *pixels = malloc(w*h*4*sizeof(GLubyte));

	glReadPixels(x, y, w, h, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w / 2; i++) {
			GLubyte *pixel1 = &pixels[4 * (j * w + i)];
			GLubyte *pixel2 = &pixels[4 * (j * w + w / 2 + i)];

			for (p = 0; p < 4; ++p) {
				probe1[p] = pixel1[p] / 255.0f;
				probe2[p] = pixel2[p] / 255.0f;
			}

			if (piglit_compare_pixels_float(probe1, probe2,
						 piglit_tolerance, 4))
				continue;

			printf("Probe color at (%i,%i)\n", x+i, x+j);
			printf("  Left: %f %f %f %f\n",
			       probe1[0], probe1[1], probe1[2], probe1[3]);
			printf("  Right: %f %f %f %f\n",
			       probe2[0], probe2[1], probe2[2], probe2[3]);

			free(pixels);
			return 0;
		}
	}

	free(pixels);
	return 1;
}

int
piglit_probe_rect_rgba(int x, int y, int w, int h, const float *expected)
{
	return probe_rect(x, y, w, h, 4, expected, 0, 0, false);
}

int piglit_probe_rect_rgb_varying(int x, int y, int w, int h,
				   const float* expected, size_t stride)
{
	assert(stride % sizeof(float) == 0);
	return probe_rect(x, y, w, h, 3, expected,
			  3, stride / sizeof(float), false);
}

int piglit_probe_rect_rgba_varying(int x, int y, int w, int h,
				   const float* expected, size_t stride)
{
	assert(stride % sizeof(float) == 0);
	return probe_rect(x, y, w, h, 4, expected,
			  4, stride / sizeof(float), false);
}

int
piglit_probe_rect_rgba_int(int x, int y, int w, int h, const int *expected)
{
	int i, j, p;
	GLint *probe;
	GLint *pixels = malloc(w*h*4*sizeof(int));

	glReadPixels(x, y, w, h, GL_RGBA_INTEGER, GL_INT, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			probe = &pixels[(j*w+i)*4];

			for (p = 0; p < 4; ++p) {
				if (probe[p] != expected[p]) {
					printf("Probe color at (%d,%d)\n", x+i, y+j);
					printf("  Expected: %d %d %d %d\n",
					       expected[0], expected[1], expected[2], expected[3]);
					printf("  Observed: %d %d %d %d\n",
					       probe[0], probe[1], probe[2], probe[3]);

					free(pixels);
					return 0;
				}
			}
		}
	}

	free(pixels);
	return 1;
}

int
piglit_probe_rect_rgba_uint(int x, int y, int w, int h,
			    const unsigned int *expected)
{
	int i, j, p;
	GLuint *probe;
	GLuint *pixels = malloc(w*h*4*sizeof(unsigned int));

	glReadPixels(x, y, w, h, GL_RGBA_INTEGER, GL_UNSIGNED_INT, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			probe = &pixels[(j*w+i)*4];

			for (p = 0; p < 4; ++p) {
				if (probe[p] != expected[p]) {
					printf("Probe color at (%d,%d)\n", x+i, y+j);
					printf("  Expected: %u %u %u %u\n",
					       expected[0], expected[1], expected[2], expected[3]);
					printf("  Observed: %u %u %u %u\n",
					       probe[0], probe[1], probe[2], probe[3]);

					free(pixels);
					return 0;
				}
			}
		}
	}

	free(pixels);
	return 1;
}

/**
 * Read color data from the given rectangle and compare its RGB value to the
 * given two expected values.
 *
 * Print a log message if the color value deviates from both expected values.
 * \return true if the color values match, false otherwise
 */
bool
piglit_probe_rect_two_rgb(int x, int y, int w, int h,
			  const float *expected1, const float *expected2)
{
	/* RGBA readbacks are likely to be faster */
	float *pixels = piglit_read_pixels_float(x, y, w, h, GL_RGBA, NULL);

	for (int j = 0; j < h; j++) {
		for (int i = 0; i < w; i++) {
			float *probe = &pixels[(j * w + i) * 4];

			if (piglit_compare_pixels_float(probe, expected1,
						 piglit_tolerance, 3) ||
			    piglit_compare_pixels_float(probe, expected2,
						 piglit_tolerance, 3))
				continue;

			printf("Probe color at (%i,%i)\n", x + i, y + j);
			printf("  Expected either:");
			print_components_float(expected1, 3);
			printf("\n  or:");
			print_components_float(expected2, 3);
			printf("\n  Observed:");
			print_components_float(probe, 3);
			printf("\n");

			free(pixels);
			return false;
		}
	}

	free(pixels);
	return true;
}

/**
 * Compute the appropriate tolerance for comparing images of the given
 * base format.
 */
void
piglit_compute_probe_tolerance(GLenum format, float *tolerance)
{
	int num_components, component;
	switch (format) {
	case GL_LUMINANCE_ALPHA:
		tolerance[0] = piglit_tolerance[0];
		tolerance[1] = piglit_tolerance[3];
		break;
	case GL_ALPHA:
		tolerance[0] = piglit_tolerance[3];
		break;
	default:
		num_components = piglit_num_components(format);
		for (component = 0; component < num_components; ++component)
			tolerance[component] = piglit_tolerance[component];
		break;
	}
}

int
piglit_compare_pixels(int x, int y, const float *expected, const float *probe,
			 const float *tolerance, int num_components)
{
	if (piglit_compare_pixels_float(probe, expected, tolerance, num_components))
		return 1;

	printf("Probe at (%i,%i)\n", x, y);
	printf("  Expected:");
	print_components_float(expected, num_components);
	printf("\n  Observed:");
	print_components_float(probe, num_components);
	printf("\n");

	return 0;
}

int
piglit_compare_image_halves_color(int w, int h, int num_components,
			    const float *tolerance,
			    const float *image)
{
	int i, j, half_width;

	half_width = w/2;
	for (j = 0; j < h; j++) {
		for (i = 0; i < half_width; i++) {
			const float *probe =
				&image[(j*w+i)*num_components];
			const float *expected =
				&image[(j*w+half_width+i)*num_components];
			if (!piglit_compare_pixels(i, j, expected, probe,
						tolerance,
						num_components))
				return 0;
		}
	}

	return 1;
}

/**
 * Compare two in-memory floating-point images.
 */
int
piglit_compare_images_color(int x, int y, int w, int h, int num_components,
			    const float *tolerance,
			    const float *expected_image,
			    const float *observed_image)
{
	int i, j;
	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			const float *expected =
				&expected_image[((j + y) * w + i + x) *
						num_components];
			const float *probe =
				&observed_image[((j + y) * w + i + x) *
						num_components];

			if (piglit_compare_pixels_float(probe, expected, tolerance,
						 num_components))
				continue;

			printf("Probe at (%i,%i)\n", x+i, y+j);
			printf("  Expected:");
			print_components_float(expected, num_components);
			printf("\n  Observed:");
			print_components_float(probe, num_components);
			printf("\n");

			return 0;
		}
	}

	return 1;
}

/**
 * Compare the region indicated by x, y, w and h of the current read
 * framebuffer with the given in-memory floating-point image of
 * dimensions w*h.
 */
int
piglit_probe_image_color(int x, int y, int w, int h, GLenum format,
			 const float *image)
{
	int c = piglit_num_components(format);
	GLfloat *pixels;
	float tolerance[4];
	int result;

	piglit_compute_probe_tolerance(format, tolerance);

	if (format == GL_INTENSITY) {
		/* GL_INTENSITY is not allowed for ReadPixels so
		 * substitute GL_LUMINANCE.
		 */
		format = GL_LUMINANCE;
	}

	pixels = piglit_read_pixels_float(x, y, w, h, format, NULL);

	result = piglit_compare_images_color(0, 0, w, h, c, tolerance, image,
					     pixels);

	free(pixels);
	return result;
}

int
piglit_probe_image_rgb(int x, int y, int w, int h, const float *image)
{
	return piglit_probe_image_color(x, y, w, h, GL_RGB, image);
}

int
piglit_probe_image_rgba(int x, int y, int w, int h, const float *image)
{
	return piglit_probe_image_color(x, y, w, h, GL_RGBA, image);
}

/**
 * Compare two in-memory unsigned-byte images.
 */
int
piglit_compare_images_ubyte(int x, int y, int w, int h,
			    const GLubyte *expected_image,
			    const GLubyte *observed_image)
{
	int i, j;
	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			const GLubyte expected = expected_image[j*w+i];
			const GLubyte probe = observed_image[j*w+i];

			if (probe != expected) {
				printf("Probe at (%i,%i)\n", x+i, y+j);
				printf("  Expected: %d\n", expected);
				printf("  Observed: %d\n", probe);

				return 0;
			}
		}
	}

	return 1;
}

/**
 * Compare the image (array) stored in \p observed with the image obtained from
 * \p expected_original with the box described by ux,uy,uz and uw,uh,ud
 * replaced by \p expected_updated.
 *
 * Only the highest \p bits bits of all four channels are compared.
 */
int
piglit_equal_images_update_rgba8(const GLubyte *expected_original,
				 const GLubyte *expected_updated,
				 const GLubyte *observed,
				 unsigned w, unsigned h, unsigned d,
				 unsigned ux, unsigned uy, unsigned uz,
				 unsigned uw, unsigned uh, unsigned ud,
				 unsigned bits)
{
	assert(bits > 0 && bits <= 8);

	unsigned x, y, z;
	const uint8_t compare_mask = 0xff << (8 - bits);

	for (z = 0; z < d; ++z) {
		for (y = 0; y < h; y++) {
			for (x = 0; x < w; x++) {
				const GLubyte *ref;

				if (x >= ux && x < ux + uw &&
				    y >= uy && y < uy + uh &&
				    z >= uz && z < uz + ud)
					ref = expected_updated;
				else
					ref = expected_original;

				bool fail =
					((ref[0] ^ observed[0]) |
					 (ref[1] ^ observed[1]) |
					 (ref[2] ^ observed[2]) |
					 (ref[3] ^ observed[3])) &
					compare_mask;
				if (fail) {
					printf("%u,%u,%u: test = %u,%u,%u,%u "
						"ref = %u,%u,%u,%u (comparing %u bits)\n",
						x, y, z,
						observed[0], observed[1],
						observed[2], observed[3],
						ref[0], ref[1], ref[2], ref[3],
						bits);
					return 0;
				}

				observed += 4;
				expected_original += 4;
				expected_updated += 4;
			}
		}
	}

	return 1;
}

/**
 * Compare the contents of the current read framebuffer's stencil
 * buffer with the given in-memory byte image.
 */
int
piglit_probe_image_stencil(int x, int y, int w, int h,
			   const GLubyte *image)
{
	GLubyte *pixels = malloc(w*h*sizeof(GLubyte));
	int result;
	GLint old_pack_alignment;

	/* Temporarily set pack alignment to 1 so that glReadPixels
	 * won't put any padding at the end of the row.
	 */
	glGetIntegerv(GL_PACK_ALIGNMENT, &old_pack_alignment);
	glPixelStorei(GL_PACK_ALIGNMENT, 1);

	glReadPixels(x, y, w, h, GL_STENCIL_INDEX, GL_UNSIGNED_BYTE, pixels);

	glPixelStorei(GL_PACK_ALIGNMENT, old_pack_alignment);

	result = piglit_compare_images_ubyte(x, y, w, h, image, pixels);

	free(pixels);
	return result;
}

int
piglit_probe_image_ubyte(int x, int y, int w, int h, GLenum format,
			const GLubyte *image)
{
	const int c = piglit_num_components(format);
	GLubyte *pixels = malloc(w * h * 4 * sizeof(GLubyte));
	int i, j;
	GLubyte tolerance[4];

	array_float_to_ubyte_roundup(4, piglit_tolerance, tolerance);

	glReadPixels(x, y, w, h, format, GL_UNSIGNED_BYTE, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			const GLubyte *expected = &image[(j * w + i) * c];
			const GLubyte *probe = &pixels[(j * w + i) * c];

			if (compare_pixels_ubyte(probe, expected, tolerance,
						 c))
				continue;

			printf("Probe at (%i,%i)\n", x + i, y + j);
			printf("  Expected:");
			print_components_ubyte(expected, c);
			printf("\n  Observed:");
			print_components_ubyte(probe, c);
			printf("\n");

			free(pixels);
			return 0;
		}
	}

	free(pixels);
	return 1;
}

#ifndef PIGLIT_USE_OPENGL
static GLuint
create_fbo_from_texture(GLenum target, GLint texture, GLint level, GLint layer)
{
	GLuint fbo;

	glGenFramebuffers(1, &fbo);
	glBindFramebuffer(GL_FRAMEBUFFER, fbo);

	if (layer > 0) {
		glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
					  texture, level, layer);
	} else {
		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
				       target, texture, level);
	}

	assert(glCheckFramebufferStatus(GL_FRAMEBUFFER) ==
	       GL_FRAMEBUFFER_COMPLETE);
	return fbo;
}

static GLenum
binding_from_target(GLenum target)
{
	switch (target)	{
	case GL_TEXTURE_2D:
		return GL_TEXTURE_BINDING_2D;
	case GL_TEXTURE_2D_ARRAY:
		return GL_TEXTURE_BINDING_2D_ARRAY;
	default:
		fprintf(stderr, "%s: unsupported target 0x%x\n",
			__func__, target);
		return 0;
	}
}

/**
 * Read texels in OpenGL ES compatible way.
 *
 * Currently bound texture is attached to a framebuffer object and
 * contents are read using glReadPixels. Supported targets are
 * GL_TEXTURE_2D, GL_TEXTURE_2D_ARRAY.
 */
static GLfloat *
read_texture_via_fbo(int target, int level, int x, int y, int layer, int w,
		     int h)
{
	GLint width, height, depth;
	GLint current_read_fbo, current_draw_fbo, current_texture;
	GLenum binding = binding_from_target(target);
	unsigned char *buf;
	GLfloat *buffer;
	unsigned offset;

	assert(binding != 0);

	glGetIntegerv(binding, &current_texture);
	glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &current_read_fbo);
	glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &current_draw_fbo);

	assert(target == GL_TEXTURE_2D || target == GL_TEXTURE_2D_ARRAY);

	glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
	glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
	glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);

	/* Depth equals 1 in case of GL_TEXTURE_2D, in case of
	 * GL_TEXTURE_2D_ARRAY we allocate space for many layers.
	 */
	buffer = malloc(width * height * depth * 4 * sizeof(GLfloat));
	buf = malloc(width * height * depth * 4 * sizeof(unsigned char));

	/* Read all layers. */
	for (int i = layer; i >= 0; i--) {
		GLuint fbo =
			create_fbo_from_texture(target, current_texture, level,
						i);
		assert(fbo != 0);

		/* Offset to the layer we are expected to read. Note, in case
		 * of GL_TEXTURE_2D, offset will be always 0 as i equals 0.
		 */
		offset = i * (width * height * 4);
		glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE,
			     buf + offset);

		glDeleteFramebuffers(1, &fbo);
	}

	/* Convert the result, callers expect floating point. */
	for (unsigned k = 0; k < (layer + 1) * width * height * 4; k++)
		buffer[k] = ((float) buf[k]) / 255.0;

	free(buf);

	/* Restore FBO state. */
	glBindFramebuffer(GL_READ_FRAMEBUFFER, current_read_fbo);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, current_draw_fbo);

	return buffer;
}
#endif


/**
 * Read a texel rectangle from the given location and compare its RGB value to
 * the given expected values.
 *
 * Print a log message if the color value deviates from the expected value.
 * \return true if the color values match, false otherwise
 */
int piglit_probe_texel_rect_rgb(int target, int level, int x, int y,
				int w, int h, const float* expected)
{
	GLfloat *buffer;
	GLfloat *probe;
	int i, j;
	GLint width;
	GLint height;

	glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
	glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
	buffer = malloc(width * height * 3 * sizeof(GLfloat));

	glGetTexImage(target, level, GL_RGB, GL_FLOAT, buffer);

	assert(x >= 0);
	assert(y >= 0);
	assert(x+w <= width);
	assert(y+h <= height);

	for (j = y; j < y+h; ++j) {
		for (i = x; i < x+w; ++i) {
			probe = &buffer[(j * width + i) * 3];

			if (piglit_compare_pixels_float(probe, expected,
						 piglit_tolerance, 3))
				continue;

			free(buffer);
			return 0;
		}
	}

	free(buffer);
	return 1;
}

/**
 * Read a texel from the given location and compare its RGB value to the
 * given expected values.
 *
 * Print a log message if the color value deviates from the expected value.
 * \return true if the color values match, false otherwise
 */
int piglit_probe_texel_rgb(int target, int level, int x, int y,
			   const float *expected)
{
	return piglit_probe_texel_rect_rgb(target, level, x, y, 1, 1, expected);
}

/**
 * Read a texel rectangle from the given location and compare its RGBA value to
 * the given expected values.
 *
 * Print a log message if the color value deviates from the expected value.
 * \return true if the color values match, false otherwise
 */
int piglit_probe_texel_rect_rgba(int target, int level, int x, int y,
				 int w, int h, const float* expected)
{
	GLfloat *buffer;
	GLfloat *probe;
	int i, j;
	GLint width;
	GLint height;

	glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
	glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);

#ifndef PIGLIT_USE_OPENGL
	if (target == GL_TEXTURE_2D) {
		buffer = read_texture_via_fbo(target, level, x, y, 0, w, h);
	} else {
#else
		buffer = malloc(width * height * 4 * sizeof(GLfloat));
		glGetTexImage(target, level, GL_RGBA, GL_FLOAT, buffer);
#endif
#ifndef PIGLIT_USE_OPENGL
	}
#endif
	assert(x >= 0);
	assert(y >= 0);
	assert(x+w <= width);
	assert(y+h <= height);

	for (j = y; j < y+h; ++j) {
		for (i = x; i < x+w; ++i) {
			probe = &buffer[(j * width + i) * 4];

			if (piglit_compare_pixels_float(probe, expected,
						 piglit_tolerance, 4))
				continue;

			print_bad_pixel_float(i, j, 4,
					      expected,
					      probe);

			free(buffer);
			return 0;
		}
	}

	free(buffer);
	return 1;
}

/**
 * Read a texel from the given location and compare its RGBA value to the
 * given expected values.
 *
 * Print a log message if the color value deviates from the expected value.
 * \return true if the color values match, false otherwise
 */
int piglit_probe_texel_rgba(int target, int level, int x, int y,
			    const float* expected)
{
	return piglit_probe_texel_rect_rgba(target, level, x, y, 1, 1,
					    expected);
}

/**
 * Read a texel rectangle from the given location and compare its RGBA value to
 * the given expected values.
 *
 * Print a log message if the color value deviates from the expected value.
 * \return true if the color values match, false otherwise
 */
int piglit_probe_texel_volume_rgba(int target, int level, int x, int y, int z,
				 int w, int h, int d, const float* expected)
{
	GLfloat *buffer;
	GLfloat *probe;
	int i, j, k;
	GLint width;
	GLint height;
	GLint depth;

	glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, &width);
	glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, &height);
	glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, &depth);

#ifndef PIGLIT_USE_OPENGL
	if (target == GL_TEXTURE_2D_ARRAY) {
		buffer = read_texture_via_fbo(target, level, x, y, z, w, h);
	} else {
#else
		buffer = malloc(width * height * depth * 4 * sizeof(GLfloat));
		glGetTexImage(target, level, GL_RGBA, GL_FLOAT, buffer);
#endif
#ifndef PIGLIT_USE_OPENGL
	}
#endif
	assert(x >= 0);
	assert(y >= 0);
	assert(d >= 0);
	assert(x+w <= width);
	assert(y+h <= height);
	assert(z+d <= depth);

	for (k = z; k < z+d; ++k) {
		for (j = y; j < y+h; ++j) {
			for (i = x; i < x+w; ++i) {
				probe = &buffer[(k * width * height + j * width + i) * 4];

				if (piglit_compare_pixels_float(probe, expected,
							 piglit_tolerance, 4))
					continue;

				printf("Probe color at (%i,%i,%i)\n",
				       i, j, k);
				printf("  Expected: ");
				print_components_float(expected, 4);
				printf("\n  Observed: ");
				print_components_float(probe, 4);
				printf("\n");

				free(buffer);
				return 0;
			}
		}
	}

	free(buffer);
	return 1;
}

/**
 * Read a pixel from the given location and compare its depth value to the
 * given expected value.
 *
 * Print a log message if the depth value deviates from the expected value.
 * \return true if the depth value matches, false otherwise
 */
int piglit_probe_pixel_depth(int x, int y, float expected)
{
	GLfloat probe;
	GLfloat delta;

	glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &probe);

	delta = probe - expected;
	if (fabs(delta) < 0.01)
		return 1;

	printf("Probe depth at (%i,%i)\n", x, y);
	printf("  Expected: %f\n", expected);
	printf("  Observed: %f\n", probe);

	return 0;
}

int piglit_probe_rect_depth(int x, int y, int w, int h, float expected)
{
	int i, j;
	GLfloat *probe;
	GLfloat *pixels = malloc(w*h*sizeof(float));

	glReadPixels(x, y, w, h, GL_DEPTH_COMPONENT, GL_FLOAT, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			probe = &pixels[j*w+i];

			if (fabs(*probe - expected) >= 0.01) {
				printf("Probe depth at (%i,%i)\n", x+i, y+j);
				printf("  Expected: %f\n", expected);
				printf("  Observed: %f\n", *probe);

				free(pixels);
				return 0;
			}
		}
	}

	free(pixels);
	return 1;
}

int piglit_probe_pixel_stencil(int x, int y, unsigned expected)
{
	GLuint probe;
	glReadPixels(x, y, 1, 1, GL_STENCIL_INDEX, GL_UNSIGNED_INT, &probe);

	if (probe == expected)
		return 1;

	printf("Probe stencil at (%i, %i)\n", x, y);
	printf("  Expected: %u\n", expected);
	printf("  Observed: %u\n", probe);

	return 0;
}

int piglit_probe_rect_stencil(int x, int y, int w, int h, unsigned expected)
{
	int i, j;
	GLuint *pixels = malloc(w*h*sizeof(GLuint));

	glReadPixels(x, y, w, h, GL_STENCIL_INDEX, GL_UNSIGNED_INT, pixels);

	for (j = 0; j < h; j++) {
		for (i = 0; i < w; i++) {
			GLuint probe = pixels[j * w + i];
			if (probe != expected) {
				printf("Probe stencil at (%i, %i)\n", x + i, y + j);
				printf("  Expected: %u\n", expected);
				printf("  Observed: %u\n", probe);
				free(pixels);
				return 0;
			}
		}
	}

	free(pixels);
	return 1;
}

bool piglit_probe_buffer(GLuint buf, GLenum target, const char *label,
		         unsigned n, unsigned num_components,
			 const float *expected)
{
	float *ptr;
	unsigned i;
	bool status = true;

	glBindBuffer(target, buf);
	ptr = glMapBuffer(target, GL_READ_ONLY);

	for (i = 0; i < n * num_components; i++) {
		if (fabs(ptr[i] - expected[i % num_components]) > 0.01) {
			printf("%s[%i]: %f, Expected: %f\n", label, i, ptr[i],
				expected[i % num_components]);
			status = false;
		}
	}

	glUnmapBuffer(target);

	return status;
}

bool piglit_probe_buffer_doubles(GLuint buf, GLenum target, const char *label,
				 unsigned n, unsigned num_components,
				 const double *expected)
{
	double *ptr;
	unsigned i;
	bool status = true;

	glBindBuffer(target, buf);
	ptr = glMapBuffer(target, GL_READ_ONLY);

	for (i = 0; i < n * num_components; i++) {
		if (fabs(ptr[i] - expected[i % num_components]) > 0.01) {
			printf("%s[%i]: %f, Expected: %f\n", label, i, ptr[i],
				expected[i % num_components]);
			status = false;
		}
	}

	glUnmapBuffer(target);

	return status;
}

int piglit_use_fragment_program(void)
{
	return piglit_is_extension_supported("GL_ARB_fragment_program");
}

void piglit_require_fragment_program(void)
{
	if (!piglit_use_fragment_program()) {
		printf("GL_ARB_fragment_program not supported.\n");
		piglit_report_result(PIGLIT_SKIP);
	}
}

int piglit_use_vertex_program(void)
{
	return piglit_is_extension_supported("GL_ARB_vertex_program");
}

void piglit_require_vertex_program(void)
{
	if (!piglit_use_vertex_program()) {
		printf("GL_ARB_vertex_program not supported.\n");
		piglit_report_result(PIGLIT_SKIP);
	}
}

GLuint piglit_compile_program(GLenum target, const char* text)
{
	GLuint program;
	GLint errorPos;

	glGenProgramsARB(1, &program);
	glBindProgramARB(target, program);
	glProgramStringARB(
			target,
			GL_PROGRAM_FORMAT_ASCII_ARB,
			strlen(text),
			(const GLubyte *)text);
	glGetIntegerv(GL_PROGRAM_ERROR_POSITION_ARB, &errorPos);
	if (glGetError() != GL_NO_ERROR || errorPos != -1) {
		int l = piglit_find_line(text, errorPos);
		int a;

		fprintf(stderr, "Compiler Error (pos=%d line=%d): %s\n",
			errorPos, l,
			(char *) glGetString(GL_PROGRAM_ERROR_STRING_ARB));

		for (a=-10; a<10; a++)
		{
			if (errorPos+a < 0)
				continue;
			if (errorPos+a >= strlen(text))
				break;
			fprintf(stderr, "%c", text[errorPos+a]);
		}
		fprintf(stderr, "\nin program:\n%s", text);
		piglit_report_result(PIGLIT_FAIL);
	}
	if (!glIsProgramARB(program)) {
		fprintf(stderr, "glIsProgramARB failed\n");
		piglit_report_result(PIGLIT_FAIL);
	}

	return program;
}

/**
 * Convenience function to draw a triangle.
 */
GLvoid
piglit_draw_triangle(float x1, float y1, float x2, float y2,
		     float x3, float y3)
{
	piglit_draw_triangle_z(0.0, x1, y1, x2, y2, x3, y3);
}

/**
 * Convenience function to draw a triangle at a given depth.
 */
GLvoid
piglit_draw_triangle_z(float z, float x1, float y1, float x2, float y2,
		     float x3, float y3)
{
	float verts[3][4];

	verts[0][0] = x1;
	verts[0][1] = y1;
	verts[0][2] = z;
	verts[0][3] = 1.0;
	verts[1][0] = x2;
	verts[1][1] = y2;
	verts[1][2] = z;
	verts[1][3] = 1.0;
	verts[2][0] = x3;
	verts[2][1] = y3;
	verts[2][2] = z;
	verts[2][3] = 1.0;

	glVertexPointer(4, GL_FLOAT, 0, verts);
	glEnableClientState(GL_VERTEX_ARRAY);

	glDrawArrays(GL_TRIANGLES, 0, 3);

	glDisableClientState(GL_VERTEX_ARRAY);
}

/**
 * Generate an extended checkerboard texture where the color of each quadrant
 * in a 2x2 block of tiles can be specified individually.
 *
 * \param tex                Name of the texture to be used.  If \c tex is
 *                           zero, a new texture name will be generated.
 * \param level              Mipmap level the checkerboard should be written to
 * \param width              Width of the texture image
 * \param height             Height of the texture image
 * \param horiz_square_size  Size of each checkerboard tile along the X axis
 * \param vert_square_size   Size of each checkerboard tile along the Y axis
 * \param bl                 RGBA color to be used for "bottom-left" tiles
 * \param br                 RGBA color to be used for "bottom-right" tiles
 * \param tl                 RGBA color to be used for "top-left" tiles
 * \param tr                 RGBA color to be used for "top-right" tiles
 *
 * The texture data is written to LOD \c level of the texture \c tex.
 *
 * If \c tex is zero, a new texture created.  This texture will have several
 * texture parameters set to non-default values:
 *
 *  - Min and mag filter will be set to \c GL_NEAREST.
 *  - For GL:
 *    - S and T wrap modes will be set to \c GL_CLAMP_TO_BORDER.
 *    - Border color will be set to { 1.0, 0.0, 0.0, 1.0 }.
 *  - For GLES:
 *    - S and T wrap modes will be set to \c GL_CLAMP_TO_EDGE.
 *
 * \return
 * Name of the texture.  In addition, this texture will be bound to the
 * \c GL_TEXTURE_2D target of the currently active texture unit.
 */
GLuint
piglit_quads_texture(GLuint tex, unsigned level,
		     unsigned width, unsigned height,
		     unsigned horiz_square_size,
		     unsigned vert_square_size,
		     const float *bl, const float *br,
		     const float *tl, const float *tr)
{
	static const GLfloat border_color[4] = { 1.0, 0.0, 0.0, 1.0 };
	unsigned i;
	unsigned j;
	void *tex_data;
	char *texel;
	unsigned pixel_size;
	GLubyte bl_b[4], br_b[4], tl_b[4], tr_b[4];
	const void *bl_data, *br_data, *tl_data, *tr_data;

	if (piglit_is_gles()) {
		pixel_size = 4 * sizeof(GLubyte);
		for (i = 0; i < 4; i++) {
			bl_b[i] = bl[i] * 255;
			br_b[i] = br[i] * 255;
			tl_b[i] = tl[i] * 255;
			tr_b[i] = tr[i] * 255;
		}
		bl_data = bl_b;
		br_data = br_b;
		tl_data = tl_b;
		tr_data = tr_b;
	} else {
		pixel_size = 4 * sizeof(float);
		bl_data = bl;
		br_data = br;
		tl_data = tl;
		tr_data = tr;
	}
	texel = tex_data = malloc(width * height * pixel_size);

	for (i = 0; i < height; i++) {
		const unsigned row = i / vert_square_size;

		for (j = 0; j < width; j++) {
			const unsigned col = j / horiz_square_size;

			if (row & 1) {
				if (col & 1)
					memcpy(texel, tr_data, pixel_size);
				else
					memcpy(texel, tl_data, pixel_size);
			} else {
				if (col & 1)
					memcpy(texel, br_data, pixel_size);
				else
					memcpy(texel, bl_data, pixel_size);
			}

			texel += pixel_size;
		}
	}

	if (tex == 0) {
		glGenTextures(1, &tex);

		glBindTexture(GL_TEXTURE_2D, tex);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
				GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
				GL_NEAREST);
		if (piglit_is_gles()) {
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
					GL_CLAMP_TO_EDGE);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
					GL_CLAMP_TO_EDGE);
		} else {
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
					GL_CLAMP_TO_BORDER);
			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
					GL_CLAMP_TO_BORDER);
			glTexParameterfv(GL_TEXTURE_2D,
					 GL_TEXTURE_BORDER_COLOR,
					 border_color);
		}
	} else {
		glBindTexture(GL_TEXTURE_2D, tex);
	}

	glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA, width, height, 0, GL_RGBA,
		     piglit_is_gles() ? GL_UNSIGNED_BYTE : GL_FLOAT, tex_data);

	free(tex_data);

	return tex;
}

/**
 * Generate a checkerboard texture
 *
 * \param tex                Name of the texture to be used.  If \c tex is
 *                           zero, a new texture name will be generated.
 * \param level              Mipmap level the checkerboard should be written to
 * \param width              Width of the texture image
 * \param height             Height of the texture image
 * \param horiz_square_size  Size of each checkerboard tile along the X axis
 * \param vert_square_size   Size of each checkerboard tile along the Y axis
 * \param black              RGBA color to be used for "black" tiles
 * \param white              RGBA color to be used for "white" tiles
 *
 * A texture with alternating black and white squares in a checkerboard
 * pattern is generated.  The texture data is written to LOD \c level of
 * the texture \c tex.
 *
 * If \c tex is zero, a new texture created.  This texture will have several
 * texture parameters set to non-default values:
 *
 *  - Min and mag filter will be set to \c GL_NEAREST.
 *  - For GL:
 *    - S and T wrap modes will be set to \c GL_CLAMP_TO_BORDER.
 *    - Border color will be set to { 1.0, 0.0, 0.0, 1.0 }.
 *  - For GLES:
 *    - S and T wrap modes will be set to \c GL_CLAMP_TO_EDGE.
 *
 * \return
 * Name of the texture.  In addition, this texture will be bound to the
 * \c GL_TEXTURE_2D target of the currently active texture unit.
 */
GLuint
piglit_checkerboard_texture(GLuint tex, unsigned level,
			    unsigned width, unsigned height,
			    unsigned horiz_square_size,
			    unsigned vert_square_size,
			    const float *black, const float *white)
{
	return piglit_quads_texture(tex, level, width, height,
				    horiz_square_size, vert_square_size,
				    black, white, white, black);
}

/**
 * Generates a 8x8 mipmapped texture whose layers contain solid r, g, b, and w.
 */
GLuint
piglit_miptree_texture()
{
	GLfloat *data;
	int size, i, level;
	GLuint tex;

	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D, tex);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
			GL_NEAREST_MIPMAP_NEAREST);

	for (level = 0; level < 4; ++level) {
		size = 8 >> level;

		data = malloc(size*size*4*sizeof(GLfloat));
		for (i = 0; i < size * size; ++i) {
			memcpy(data + 4 * i, color_wheel[level],
			       4 * sizeof(GLfloat));
		}
		glTexImage2D(GL_TEXTURE_2D, level, GL_RGBA,
			     size, size, 0, GL_RGBA, GL_FLOAT, data);
		free(data);
	}
	return tex;
}

/**
 * Generates an image of the given size with quadrants of red, green,
 * blue and white.
 * Note that for compressed teximages, where the blocking would be
 * problematic, we assign the whole layers at w == 4 to red, w == 2 to
 * green, and w == 1 to blue.
 *
 * \param internalFormat  either GL_RGBA or a specific compressed format
 * \param w  the width in texels
 * \param h  the height in texels
 * \param alpha  if TRUE, use varied alpha values, else all alphas = 1
 * \param basetype  either GL_UNSIGNED_NORMALIZED, GL_SIGNED_NORMALIZED
 *                  or GL_FLOAT
 */
GLfloat *
piglit_rgbw_image(GLenum internalFormat, int w, int h,
		  GLboolean alpha, GLenum basetype)
{
	float red[4]   = {1.0, 0.0, 0.0, 0.0};
	float green[4] = {0.0, 1.0, 0.0, 0.25};
	float blue[4]  = {0.0, 0.0, 1.0, 0.5};
	float white[4] = {1.0, 1.0, 1.0, 1.0};
	GLfloat *data;
	int x, y;

	if (!alpha) {
		red[3] = 1.0;
		green[3] = 1.0;
		blue[3] = 1.0;
		white[3] = 1.0;
	}

	switch (basetype) {
	case GL_UNSIGNED_NORMALIZED:
		break;

	case GL_SIGNED_NORMALIZED:
		for (x = 0; x < 4; x++) {
			red[x] = red[x] * 2 - 1;
			green[x] = green[x] * 2 - 1;
			blue[x] = blue[x] * 2 - 1;
			white[x] = white[x] * 2 - 1;
		}
		break;

	case GL_FLOAT:
		for (x = 0; x < 4; x++) {
			red[x] = red[x] * 10 - 5;
			green[x] = green[x] * 10 - 5;
			blue[x] = blue[x] * 10 - 5;
			white[x] = white[x] * 10 - 5;
		}
		break;

	default:
		assert(0);
	}

	data = malloc(w * h * 4 * sizeof(GLfloat));

	for (y = 0; y < h; y++) {
		for (x = 0; x < w; x++) {
			const int size = w > h ? w : h;
			const float *color;

			if (x < w / 2 && y < h / 2)
				color = red;
			else if (y < h / 2)
				color = green;
			else if (x < w / 2)
				color = blue;
			else
				color = white;

			switch (internalFormat) {
			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:
			case GL_COMPRESSED_RGB_FXT1_3DFX:
			case GL_COMPRESSED_RGBA_FXT1_3DFX:
			case GL_COMPRESSED_RED_RGTC1:
			case GL_COMPRESSED_SIGNED_RED_RGTC1:
			case GL_COMPRESSED_RG_RGTC2:
			case GL_COMPRESSED_SIGNED_RG_RGTC2:
			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:
			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:
				if (size == 4)
					color = red;
				else if (size == 2)
					color = green;
				else if (size == 1)
					color = blue;
				break;
			default:
				break;
			}

			memcpy(data + (y * w + x) * 4, color,
			       4 * sizeof(float));
		}
	}

	return data;
}

GLubyte *
piglit_rgbw_image_ubyte(int w, int h, GLboolean alpha)
{
	GLubyte red[4]   = {255, 0, 0, 0};
	GLubyte green[4] = {0, 255, 0, 64};
	GLubyte blue[4]  = {0, 0, 255, 128};
	GLubyte white[4] = {255, 255, 255, 255};
	GLubyte *data;
	int x, y;

	if (!alpha) {
		red[3] = 255;
		green[3] = 255;
		blue[3] = 255;
		white[3] = 255;
	}

	data = malloc(w * h * 4 * sizeof(GLubyte));

	for (y = 0; y < h; y++) {
		for (x = 0; x < w; x++) {
			const GLubyte *color;

			if (x < w / 2 && y < h / 2)
				color = red;
			else if (y < h / 2)
				color = green;
			else if (x < w / 2)
				color = blue;
			else
				color = white;

			memcpy(data + (y * w + x) * 4, color,
			       4 * sizeof(GLubyte));
		}
	}

	return data;
}

/**
 * Generates a texture with the given internalFormat, w, h with a
 * teximage of r, g, b, w quadrants.
 *
 * Note that for compressed teximages, where the blocking would be
 * problematic, we assign the whole layers at w == 4 to red, w == 2 to
 * green, and w == 1 to blue.
 */
GLuint
piglit_rgbw_texture(GLenum internalFormat, int w, int h, GLboolean mip,
		    GLboolean alpha, GLenum basetype)
{
	int size, level;
	GLuint tex;
	GLenum teximage_type;

	switch (basetype) {
	case GL_UNSIGNED_NORMALIZED:
	case GL_SIGNED_NORMALIZED:
	case GL_FLOAT:
		teximage_type = GL_FLOAT;
		break;
	case GL_UNSIGNED_BYTE:
		teximage_type = GL_UNSIGNED_BYTE;
		break;
	default:
		assert(0);
		return 0;
	}

	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D, tex);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	if (mip) {
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
				GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
				GL_LINEAR_MIPMAP_NEAREST);
	} else {
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
				GL_NEAREST);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
				GL_NEAREST);
	}

	for (level = 0, size = w > h ? w : h; size > 0; level++, size >>= 1) {
		void *data;

		if (teximage_type == GL_UNSIGNED_BYTE)
			data = piglit_rgbw_image_ubyte(w, h, alpha);
		else
			data = piglit_rgbw_image(internalFormat, w, h,
			                         alpha, basetype);

		glTexImage2D(GL_TEXTURE_2D, level,
			     internalFormat,
			     w, h, 0,
			     GL_RGBA, teximage_type, data);
		free(data);

		if (!mip)
			break;

		if (w > 1)
			w >>= 1;
		if (h > 1)
			h >>= 1;
	}

	return tex;
}

/**
 * Generate a 4 texel RGBA 1D texture with texels red, green, blue, white,
 * edge clamping and NEAREST filtering.
 */
GLuint
piglit_rgbw_texture_1d(void)
{
	GLuint tex;
	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_1D, tex);
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	static const float img[] = {1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1};
	glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 4, 0, GL_RGBA, GL_FLOAT, img);

	return tex;
}

/**
 * Generate a 2 by 2 by 2 texel RGBA 3D texture with texels red, green, blue,
 * white, yellow, magenta, cyan, black, edge clamping and NEAREST filtering.
 */
GLuint
piglit_rgbw_texture_3d(void)
{
	GLuint tex;
	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_3D, tex);
	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_WRAP_R, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

	static const float img[] = {1, 0, 0, 1, 0, 1, 0, 1,
				    0, 0, 1, 1, 1, 1, 1, 1,
				    1, 1, 0, 1, 1, 0, 1, 1,
				    0, 1, 1, 1, 0, 0, 0, 1};
	glTexImage3D(GL_TEXTURE_3D, 0, GL_RGBA, 2, 2, 2, 0, GL_RGBA, GL_FLOAT, img);

	return tex;
}

/*
 * Maps a given integer internalformat to a valid format, including
 * the num_components info.
 */
static void
map_integer_internalformat(GLenum internalformat, GLenum *format, int *num_components)
{
	switch(internalformat) {
	case GL_R32I:
		*format = GL_RED_INTEGER;
		*num_components = 1;
		break;
	case GL_RG32I:
		*format = GL_RG_INTEGER;
		*num_components = 2;
		break;
	case GL_RGB32I:
		*format = GL_RGB_INTEGER;
		*num_components = 3;
		break;
	case GL_RGBA32I:
		*format = GL_RGBA_INTEGER;
		*num_components = 4;
		break;
	default:
		printf("piglit_integer_texture only supports 32-bit integer"
		       " internalformats\n");
		piglit_report_result(PIGLIT_FAIL);
	}
}

/**
 * Generates a texture with the given integer internal format.
 * It tries to use all the 4 data references (x, y, b, a) to fill the data. So:
 *   * For 4 components: R = x, G = y, B = b, A = a.
 *   * For 3 components: R = x, G = y, B = b + a
 *   * For 2 components: R = x + b, G = y + a
 *   * For 1 components: R = x + y * b + a
 * Note that it assumes internalformats using 32 bit integer, so we would use GL_INT.
 */
GLuint piglit_integer_texture(GLenum internalFormat, int w, int h, int b, int a)
{
	int *img;
	int *p;
	GLuint tex;
	GLenum format;
	int num_components;
	int x, y;

	map_integer_internalformat(internalFormat, &format, &num_components);

	img = malloc(w * h * num_components * sizeof(int));

	for (y = 0, p = img; y < h; ++y) {
		for (x = 0; x < w; ++x) {
			switch(num_components) {
			case 4:
				p[0] = x;
				p[1] = y;
				p[2] = b;
				p[3] = a;
				break;
			case 3:
				p[0] = x;
				p[1] = y;
				p[2] = b + a;
				break;
			case 2:
				p[0] = x + b;
				p[1] = y + a;
				break;
			case 1:
				p[0] = x + y * b + a;
				break;
			}

			p += num_components;
		}
	}

	glGenTextures(1, &tex);
	glBindTexture(GL_TEXTURE_2D, tex);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
			GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
			GL_NEAREST);

	glTexStorage2D(GL_TEXTURE_2D, 1, internalFormat, w, h);
	glTexSubImage2D(GL_TEXTURE_2D,
			0, 0, 0, w, h, format, GL_INT, img);
	free(img);

	return tex;
}

/**
 * Create a depth texture.  The depth texture will be a gradient which varies
 * from 0.0 at the left side to 1.0 at the right side.  For a 2D array texture,
 * all the texture layers will have the same gradient.
 *
 * \param target  either GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_1D_ARRAY,
 *                GL_TEXTURE_2D_ARRAY or GL_TEXTURE_RECTANGLE.
 * \param internalformat  either GL_DEPTH_STENCIL, GL_DEPTH_COMPONENT,
 *                        GL_DEPTH24_STENCIL8_EXT or GL_DEPTH32F_STENCIL8.
 * \param w, h, d  level 0 image width, height and depth
 * \param mip  if true, create a full mipmap.  Else, create single-level texture.
 * \return the new texture object id
 */
GLuint
piglit_depth_texture(GLenum target, GLenum internalformat, int w, int h, int d, GLboolean mip)
{
	void *data;
	float *f = NULL, *f2 = NULL;
	unsigned int  *i = NULL;
	int size, x, y, level, layer;
	GLuint tex;
	GLenum type, format;

	glGenTextures(1, &tex);
	glBindTexture(target, tex);
	glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	if (mip) {
		glTexParameteri(target, GL_TEXTURE_MAG_FILTER,
				GL_LINEAR);
		glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
				GL_LINEAR_MIPMAP_NEAREST);
	} else {
		glTexParameteri(target, GL_TEXTURE_MAG_FILTER,
				GL_NEAREST);
		glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
				GL_NEAREST);
	}
	data = malloc(w * h * 4 * sizeof(GLfloat));

	if (internalformat == GL_DEPTH_STENCIL_EXT ||
	    internalformat == GL_DEPTH24_STENCIL8_EXT) {
		format = GL_DEPTH_STENCIL_EXT;
		type = GL_UNSIGNED_INT_24_8_EXT;
		i = data;
	} else if (internalformat == GL_DEPTH32F_STENCIL8) {
		format = GL_DEPTH_STENCIL;
		type = GL_FLOAT_32_UNSIGNED_INT_24_8_REV;
		f2 = data;
	} else {
		format = GL_DEPTH_COMPONENT;
		type = GL_FLOAT;
		f = data;
	}

	for (level = 0, size = w > h ? w : h; size > 0; level++, size >>= 1) {
		for (y = 0; y < h; y++) {
			for (x = 0; x < w; x++) {
				float val = (float)(x) / (w - 1);
				if (f)
					f[y * w + x] = val;
				else if (f2)
					f2[(y * w + x)*2] = val;
				else if (i)
					i[y * w + x] = 0xffffff00 * val;
			}
		}

		switch (target) {
		case GL_TEXTURE_1D:
			glTexImage1D(target, level,
				     internalformat,
				     w, 0,
				     format, type, data);
			break;

		case GL_TEXTURE_1D_ARRAY:
		case GL_TEXTURE_2D:
		case GL_TEXTURE_RECTANGLE:
			glTexImage2D(target, level,
				     internalformat,
				     w, h, 0,
				     format, type, data);
			break;

		case GL_TEXTURE_2D_ARRAY:
			glTexImage3D(target, level,
				     internalformat,
				     w, h, d, 0,
				     format, type, NULL);
			for (layer = 0; layer < d; layer++) {
				glTexSubImage3D(target, level,
						0, 0, layer, w, h, 1,
						format, type, data);
			}
			break;

		default:
			assert(0);
		}

		if (!mip)
			break;

		if (w > 1)
			w >>= 1;
		if (target != GL_TEXTURE_1D &&
		    target != GL_TEXTURE_1D_ARRAY &&
		    h > 1)
			h >>= 1;
	}
	free(data);
	return tex;
}

/**
 * Create 1D or 2D array texture in which each slice is a different color.
 * the color pattern is red, green, blue, white, red, green, ...
 */
GLuint
piglit_array_texture(GLenum target, GLenum internalformat,
		     int w, int h, int d, GLboolean mip)
{
	float *data;
	int size, i, level, layer;
	GLuint tex;
	GLenum type = GL_FLOAT, format = GL_RGBA;

	if (target == GL_TEXTURE_1D_ARRAY) {
		assert(h == 1);
	}
	else {
		assert(target == GL_TEXTURE_2D_ARRAY);
	}

	glGenTextures(1, &tex);
	glBindTexture(target, tex);
	glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	if (mip) {
		glTexParameteri(target, GL_TEXTURE_MAG_FILTER,
				GL_LINEAR);
		glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
				GL_LINEAR_MIPMAP_NEAREST);
	} else {
		glTexParameteri(target, GL_TEXTURE_MAG_FILTER,
				GL_NEAREST);
		glTexParameteri(target, GL_TEXTURE_MIN_FILTER,
				GL_NEAREST);
	}
	data = malloc(w * h * 4 * sizeof(GLfloat));

	size = w > h ? w : h;

	for (level = 0; size > 0; level++, size >>= 1) {

		/* Create mipmap level */
		if (target == GL_TEXTURE_1D_ARRAY) {
			glTexImage2D(target, level, internalformat,
				     w, d, 0, format, type, NULL);
		}
		else {
			glTexImage3D(target, level, internalformat,
				     w, h, d, 0, format, type, NULL);
		}

		for (layer = 0; layer < d; layer++) {
			/* Set whole layer to one color */
			for (i = 0; i < w * h; i++) {
				memcpy(data + 4 * i,
				       color_wheel[layer %
						   ARRAY_SIZE(color_wheel)],
				       sizeof(color_wheel[0]));
			}

			if (target == GL_TEXTURE_1D_ARRAY) {
				glTexSubImage2D(target, level,
						0, layer, w, 1,
						format, type, data);
			}
			else {
				glTexSubImage3D(target, level,
						0, 0, layer, w, h, 1,
						format, type, data);
			}
		}

		if (!mip)
			break;

		if (w > 1)
			w >>= 1;
		if (h > 1)
			h >>= 1;
	}
	free(data);
	return tex;
}

static const char multisample_texture_vs_source[] =
"#version 130\n"
"in vec2 vertex;\n"
"out vec2 tex_coords;\n"
"void main()\n"
"{\n"
"	tex_coords = vertex;\n"
"	vec2 pos = (vertex.xy * 2) - vec2(1, 1);\n"
"	gl_Position = vec4(pos, 0, 1);\n"
"}\n";

static const char multisample_texture_fs_source[] =
"#version 130\n"
"#extension GL_ARB_sample_shading : enable\n"
"in vec2 tex_coords;\n"
"uniform sampler2DArray tex;\n"
"uniform int tex_depth;\n"
"uniform int z;\n"
"void main()\n"
"{\n"
"	int layer = (gl_SampleID * tex_depth) + z;\n"
"	gl_FragColor = texture(tex, vec3(tex_coords, layer));\n"
"}\n";

/**
 * Uploads an arbitrary multisample texture.
 *
 * This function acts like glTexImage for multisample textures.  If the
 * input texture is zero, it will create one.  Otherwise, it will use the
 * texture given and assumes that glTexImage[23]DMultisample has already
 * been called to establish the storage.
 *
 * When this function returns, multisample texture will be bound to the
 * currently active texture.
 *
 * \param target         either GL_TEXTURE_2D_MULTISAMPLE or
 *                       GL_TEXTURE2D_MULTISAMPLE_ARRAY
 * \param tex            texture ID for existing texture, or zero
 * \param internalformat a renderable color format accepted by
 *                       glTexImage2DMultisample
 * \param width          texture width
 * \param height         texture height
 * \param depth          texture depth.  If target is
 *                       GL_TEXTURE_2D_MULTISAMPLE, this must be 1.
 * \param samples        the number of samples
 * \param format         format of the pixel data
 * \param type           type of the pixel data
 * \param data           pixel data with which to fill the texture
 *
 * \return the new texture object id
 */
GLuint
piglit_multisample_texture(GLenum target, GLuint tex, GLenum internalFormat,
			   unsigned width, unsigned height,
			   unsigned depth, unsigned samples,
			   GLenum format, GLenum type, const void *data)
{
	static GLuint prog = 0;
	static GLint tex_loc, tex_depth_loc, z_loc;
	static GLuint fbo, array_tex, ms_tex;
	static const float verts[] = {
		0.0, 0.0,
		0.0, 1.0,
		1.0, 1.0,
		1.0, 1.0,
		1.0, 0.0,
		0.0, 0.0
	};
	unsigned z;

	struct {
		GLint active_tex;
		GLint draw_fbo;
		GLint prog;
		GLint viewport[4];
		GLboolean arb_sample_shading;
		GLfloat min_sample_shading;
		GLint clamp_fragment_color;
	} backup;

	piglit_require_extension("GL_ARB_texture_multisample");
	piglit_require_extension("GL_ARB_sample_shading");

	if (target == GL_TEXTURE_2D_MULTISAMPLE) {
		assert(depth == 1);
	} else if (target == GL_TEXTURE_2D_MULTISAMPLE_ARRAY) {
	} else {
		assert(!"Invalid texture target");
		return 0;
	}

	if (prog == 0) {
		/* First-run setup */
		prog = piglit_build_simple_program_unlinked(
			multisample_texture_vs_source,
			multisample_texture_fs_source);
		glBindAttribLocation(prog, 0, "vertex");
		glLinkProgram(prog);
		if (!piglit_link_check_status(prog)) {
			prog = 0;
			return 0;
		}

		tex_loc = glGetUniformLocation(prog, "tex");
		tex_depth_loc = glGetUniformLocation(prog, "tex_depth");
		z_loc = glGetUniformLocation(prog, "z");

		glGenFramebuffers(1, &fbo);
		glGenTextures(1, &array_tex);
	}

	/* Backup client values so we can restore them later */
	glGetIntegerv(GL_ACTIVE_TEXTURE, &backup.active_tex);
	glGetIntegerv(GL_CURRENT_PROGRAM, &backup.prog);
	glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &backup.draw_fbo);
	glGetIntegerv(GL_CLAMP_FRAGMENT_COLOR, &backup.clamp_fragment_color);
	glGetIntegerv(GL_VIEWPORT, backup.viewport);
	glGetBooleanv(GL_SAMPLE_SHADING_ARB, &backup.arb_sample_shading);
	glGetFloatv(GL_MIN_SAMPLE_SHADING_VALUE_ARB, &backup.min_sample_shading);

	glEnable(GL_SAMPLE_SHADING_ARB);
	glMinSampleShadingARB(1.0f);

	if (tex) {
		ms_tex = tex;
	} else {
		glGenTextures(1, &ms_tex);
		glBindTexture(target, ms_tex);
		if (target == GL_TEXTURE_2D_MULTISAMPLE) {
			assert(depth == 1);
			glTexImage2DMultisample(target, samples, internalFormat,
						width, height, GL_TRUE);
		} else {
			glTexImage3DMultisample(target, samples, internalFormat,
						width, height, depth, GL_TRUE);
		}
	}

	glBindTexture(GL_TEXTURE_2D_ARRAY, array_tex);
	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, internalFormat, width, height,
		     depth * samples, 0, format, type, data);

	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
	glViewport(0, 0, width, height);

	glClampColor(GL_CLAMP_FRAGMENT_COLOR, GL_FALSE);

	glUseProgram(prog);
	glUniform1i(tex_loc, backup.active_tex - GL_TEXTURE0);
	glUniform1i(tex_depth_loc, depth);

	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, verts);

	if (target == GL_TEXTURE_2D_MULTISAMPLE) {
		glUniform1i(z_loc, 0);
		glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER,
				       GL_COLOR_ATTACHMENT0,
				       target, ms_tex, 0);
		if (glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) !=
		    GL_FRAMEBUFFER_COMPLETE)
			goto error;

		glDrawArrays(GL_TRIANGLES, 0, 6);
	} else {
		for (z = 0; z < depth; ++z) {
			glUniform1i(z_loc, z);
			glFramebufferTextureLayer(GL_DRAW_FRAMEBUFFER,
						  GL_COLOR_ATTACHMENT0,
						  ms_tex, 0, z);
			if (glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER) !=
			    GL_FRAMEBUFFER_COMPLETE)
				goto error;

			glDrawArrays(GL_TRIANGLES, 0, 6);
		}
	}

	glDisableVertexAttribArray(0);

	/* Restore values for the client */
	if (!backup.arb_sample_shading)
		glDisable(GL_SAMPLE_SHADING_ARB);
	glMinSampleShadingARB(backup.min_sample_shading);

	glUseProgram(backup.prog);
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, backup.draw_fbo);
	glViewport(backup.viewport[0], backup.viewport[1],
		   backup.viewport[2], backup.viewport[3]);
	glBindTexture(target, ms_tex);
	glClampColor(GL_CLAMP_FRAGMENT_COLOR, backup.clamp_fragment_color);

	return ms_tex;

error:
	if (tex == 0) /* We created it, clean it up */
		glDeleteTextures(1, &ms_tex);

	return 0;
}

/**
 * Require transform feedback.
 *
 * Transform feedback may either be provided by GL 3.0 or
 * EXT_transform_feedback.
 */
void
piglit_require_transform_feedback(void)
{
	if (!(piglit_get_gl_version() >= 30 ||
	      piglit_is_extension_supported("GL_EXT_transform_feedback"))) {
		printf("Transform feedback not supported.\n");
		piglit_report_result(PIGLIT_SKIP);
	}
}

/**
 * Convert the image into a format that can be easily understood by
 * visual inspection, and display it on the screen.
 *
 * Luminance and intensity values are converted to a grayscale value.
 * Alpha values are visualized by blending the image with a grayscale
 * checkerboard.
 *
 * Pass image_count = 0 to disable drawing multiple images to window
 * system framebuffer.
 */
void
piglit_visualize_image(float *img, GLenum base_internal_format,
		       int image_width, int image_height,
		       int image_count, bool rhs)
{
	int x, y;
	float checker;
	unsigned components = piglit_num_components(base_internal_format);
	float *visualization =
		(float *) malloc(sizeof(float)*3*image_width*image_height);
	for (y = 0; y < image_height; ++y) {
		for ( x = 0; x < image_width; ++x) {
			float r = 0, g = 0, b = 0, a = 1;
			float *pixel =
				&img[(y * image_width + x) * components];
			switch (base_internal_format) {
			case GL_ALPHA:
				a = pixel[0];
				break;
			case GL_RGBA:
				a = pixel[3];
				/* Fall through */
			case GL_RGB:
				b = pixel[2];
				/* Fall through */
			case GL_RG:
				g = pixel[1];
				/* Fall through */
			case GL_RED:
				r = pixel[0];
				break;
			case GL_LUMINANCE_ALPHA:
				a = pixel[1];
				/* Fall through */
			case GL_INTENSITY:
			case GL_LUMINANCE:
				r = pixel[0];
				g = pixel[0];
				b = pixel[0];
				break;
			}
			checker = ((x ^ y) & 0x10) ? 0.75 : 0.25;
			r = r * a + checker * (1 - a);
			g = g * a + checker * (1 - a);
			b = b * a + checker * (1 - a);
			visualization[(y * image_width + x) * 3] = r;
			visualization[(y * image_width + x) * 3 + 1] = g;
			visualization[(y * image_width + x) * 3 + 2] = b;
		}
	}
	glBindFramebuffer(GL_DRAW_FRAMEBUFFER, piglit_winsys_fbo);
	glUseProgram(0);

	/* To simultaneously display multiple images on window system
	 * framebuffer.
	 */
	if(image_count) {
		/* Use glWindowPos to directly update x, y coordinates of
		 * current raster position without getting transformed by
		 * modelview projection matrix and viewport-to-window
		 * transform.
		 */
		glWindowPos2f(rhs ? image_width : 0,
			      (image_count - 1) * image_height);
	}
	else {
		glRasterPos2f(rhs ? 0 : -1, -1);
	}
	glDrawPixels(image_width, image_height, GL_RGB, GL_FLOAT,
		     visualization);
	free(visualization);
}

/**
 * Convert from sRGB color space to linear color space, using the
 * formula from the GL 3.0 spec, section 4.1.8 (sRGB Texture Color
 * Conversion).
 */
float
piglit_srgb_to_linear(float x)
{
        if (x <= 0.0405)
                return x / 12.92;
        else
                return pow((x + 0.055) / 1.055, 2.4);
}

/* Convert from linear color space to sRGB color space. */
float
piglit_linear_to_srgb(float x)
{
   if (x < 0.0f)
      return 0.0f;
   else if (x < 0.0031308f)
      return 12.92f * x;
   else if (x < 1.0f)
      return 1.055f * powf(x, 0.41666f) - 0.055f;
   else
      return 1.0f;
}
