[Piglit] [PATCH 2/4] util: Add a piglit_probe_rects_equal_rgba() function

[Nanley Chery]

From: Nanley Chery <nanley.g.chery at intel.com>

This function compares two rectangles for equality. Among other uses, this
is useful to compare the rendering of individual miplevels in a miptree.

Signed-off-by: Nanley Chery <nanley.g.chery at intel.com>
---
 tests/util/piglit-util-gl.c | 88 +++++++++++++++++++++++++++++++++++++++++++++
 tests/util/piglit-util-gl.h | 23 ++++++++++++
 2 files changed, 111 insertions(+)

diff --git a/tests/util/piglit-util-gl.c b/tests/util/piglit-util-gl.c
index 1a24067..c17b382 100644
--- a/tests/util/piglit-util-gl.c
+++ b/tests/util/piglit-util-gl.c
@@ -1240,6 +1240,41 @@ piglit_probe_rect_rgb(int x, int y, int w, int h, const float *expected)
 }
 
 int
+piglit_probe_rects_equal(int x1, int y1, int x2, int y2,
+			int w, int h, GLenum format)
+{
+	int retval;
+	GLfloat *pixels;
+	int ncomponents, rect_size;
+
+	/* Allocate buffer large enough for two rectangles */
+	ncomponents = piglit_num_components(format);
+	rect_size = w * h * ncomponents;
+	pixels = malloc(2 * rect_size * sizeof(GLfloat));
+
+	/* 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) {
+		piglit_read_pixels_float(x1, y1, 2*w, h, format, pixels);
+		retval = piglit_compare_image_halves_color(2*w, h,
+						       ncomponents,
+						       piglit_tolerance,
+						       pixels);
+	} else {
+		piglit_read_pixels_float(x1, y1, w, h, format, pixels);
+		piglit_read_pixels_float(x2, y2, w, h, format,
+					pixels +rect_size);
+		retval = piglit_compare_images_color(0, 0, w, h,
+					       ncomponents,
+					       piglit_tolerance,
+					       pixels, pixels + rect_size);
+	}
+
+	free(pixels);
+	return retval;
+}
+
+int
 piglit_probe_rect_rgba(int x, int y, int w, int h, const float *expected)
 {
 	int i, j, p;
@@ -1376,6 +1411,59 @@ piglit_compute_probe_tolerance(GLenum format, float *tolerance)
 	}
 }
 
+static inline int
+piglit_compare_pixels(const float *expected, const float *probe,
+			 const float *tolerance, int num_components)
+{
+	int p;
+
+	for (p = 0; p < num_components; ++p) {
+		if (fabs(probe[p] - expected[p]) >= tolerance[p])
+			return 0;
+	}
+
+	return 1;
+}
+
+
+static void
+print_expected_observed(int x, int y, int num_components,
+		const float *expected, const float *probe)
+{
+	printf("Probe at (%i,%i)\n", x, y);
+	printf("  Expected:");
+	print_pixel_float(expected, num_components);
+	printf("\n  Observed:");
+	print_pixel_float(probe, num_components);
+	printf("\n");
+}
+
+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(expected, probe,
+						tolerance,
+						num_components)) {
+				print_expected_observed(i, j, num_components,
+						expected, probe);
+				return 0;
+			}
+		}
+	}
+
+	return 1;
+}
+
 /**
  * Compare two in-memory floating-point images.
  */
diff --git a/tests/util/piglit-util-gl.h b/tests/util/piglit-util-gl.h
index ddba1bb..9773d01 100644
--- a/tests/util/piglit-util-gl.h
+++ b/tests/util/piglit-util-gl.h
@@ -142,6 +142,19 @@ int piglit_probe_rect_rgba(int x, int y, int w, int h, const float* expected);
 int piglit_probe_rect_rgba_int(int x, int y, int w, int h, const int* expected);
 int piglit_probe_rect_rgba_uint(int x, int y, int w, int h, const unsigned int* expected);
 void piglit_compute_probe_tolerance(GLenum format, float *tolerance);
+
+/**
+ * Compare two adjacent in-memory floating-point images.
+ * Adjacent means: y1 == y2 && x1 == x2 - w;
+ *
+ * \param w the width of the rectangle containing both images
+ * \param h the height of the rectangle containing both images
+ * \param images : the start of the buffer containing the observed image on
+ *		the left and the expected image on the right
+ */
+int piglit_compare_image_halves_color(int w, int h, int num_components,
+			    const float *tolerance,
+			    const float *expected_observed_image);
 int piglit_compare_images_color(int x, int y, int w, int h, int num_components,
 				const float *tolerance,
 				const float *expected_image,
@@ -171,6 +184,16 @@ int piglit_probe_pixel_stencil(int x, int y, unsigned expected);
 int piglit_probe_rect_stencil(int x, int y, int w, int h, unsigned expected);
 int piglit_probe_rect_halves_equal_rgba(int x, int y, int w, int h);
 
+/**
+ * \brief Check if two rectangles are equivalent
+ *
+ * Given the coordinates of two rectangles, check that the two are equal.
+ * The first rectangle is what's observed, whereas the second rectangle is
+ * what's expected.
+ */
+int piglit_probe_rects_equal(int x1, int y1, int x2, int y2,
+			int w, int h, GLenum format);
+
 bool piglit_probe_buffer(GLuint buf, GLenum target, const char *label,
 			 unsigned n, unsigned num_components,
 			 const float *expected);
-- 
2.4.2