[Piglit] [PATCH 2/5] updated gles2: new glReadPixels unit test
Tom Gall
tom.gall at linaro.org
Thu Dec 20 18:23:16 PST 2012
Small update based on feedback from Ian, Matt and Eric. Format
fixes and failing variations are no longer commented out.
Adds a "unit" test of sorts to exercise the glReadPixels
function from OpenGL ES 2.0.25, covering both valid and invalid
formats and types.
Signed-off-by: Tom Gall <tom.gall at linaro.org>
---
tests/all.tests | 1 +
tests/spec/gles-2.0/CMakeLists.gles2.txt | 1 +
tests/spec/gles-2.0/gles2_unit_glReadPixels.c | 639 +++++++++++++++++++++++++
3 files changed, 641 insertions(+)
create mode 100644 tests/spec/gles-2.0/gles2_unit_glReadPixels.c
diff --git a/tests/all.tests b/tests/all.tests
index b5d23e2..ce72d12 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -2684,6 +2684,7 @@ egl_khr_create_context['verify GL flavor'] = plain_test('egl-create-context-veri
gles20 = Group()
spec['!OpenGL ES 2.0'] = gles20
add_plain_test(gles20, 'sanity-test_gles2')
+add_plain_test(gles20, 'unit-glReadPixels_gles2')
gles30 = Group()
spec['!OpenGL ES 3.0'] = gles30
diff --git a/tests/spec/gles-2.0/CMakeLists.gles2.txt b/tests/spec/gles-2.0/CMakeLists.gles2.txt
index df3d26c..af0ee4b 100644
--- a/tests/spec/gles-2.0/CMakeLists.gles2.txt
+++ b/tests/spec/gles-2.0/CMakeLists.gles2.txt
@@ -4,5 +4,6 @@ link_libraries(
piglit_add_executable(sanity-test_${piglit_target_api} gles2_sanity_test.c)
piglit_add_executable(invalid-es3-queries_${piglit_target_api} invalid-es3-queries.c)
+piglit_add_executable(unit-glReadPixels_${piglit_target_api} gles2_unit_glReadPixels.c)
# vim: ft=cmake:
diff --git a/tests/spec/gles-2.0/gles2_unit_glReadPixels.c b/tests/spec/gles-2.0/gles2_unit_glReadPixels.c
new file mode 100644
index 0000000..7332a2d
--- /dev/null
+++ b/tests/spec/gles-2.0/gles2_unit_glReadPixels.c
@@ -0,0 +1,639 @@
+/*
+ * Copyright © 2012 Linaro Inc
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+/**
+ * This is a unit test to exercise glReadPixels
+ * as specified by the OpenGL ES 2.0 spec.
+ *
+ * Todo: GL_PACK_ALIGNMENT via glPixelStorei isn't tested
+ * reading from GL_COLOR_ATTACHMENT0 when the default framebuffer
+ * isn't bound is not tested
+ * combo of GL_IMPLEMENTATION_COLOR_READ_FORMAT
+ * GL_IMPLEMENTATION_COLOR_READ_TYPE is not tested
+ *
+ * \author Tom Gall <tom.gall at linaro.org>
+ */
+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <stdio.h>
+#include "piglit-util-gl-common.h"
+
+#define WIDTH 320
+#define HEIGHT 200
+#define TEST_PATTERN_BYTE 0xA5
+
+PIGLIT_GL_TEST_CONFIG_BEGIN
+
+ config.supports_gl_es_version = 20;
+
+ config.window_width = 320;
+ config.window_height = 200;
+ config.window_visual = PIGLIT_GL_VISUAL_RGB | PIGLIT_GL_VISUAL_DEPTH;
+
+PIGLIT_GL_TEST_CONFIG_END
+
+GLuint prog;
+GLuint frag;
+GLuint vert;
+/* pad a bit so we can do a request larger than the viewport */
+GLubyte buffer[HEIGHT+50][WIDTH][4];
+
+char vertex_shader [] =
+ "attribute vec4 vPosition;\n"
+ "void main()\n"
+ "{\n"
+ " gl_Position = vPosition;\n"
+ "}";
+
+char fragment_shader [] =
+ "precision mediump float;\n"
+ "void main()\n"
+ "{\n"
+ " gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
+ "}";
+
+/* various pixel formats */
+typedef struct {
+ unsigned short red:5;
+ unsigned short green:6;
+ unsigned short blue:5;
+} pixel_f565;
+typedef struct {
+ unsigned short red:5;
+ unsigned short green:5;
+ unsigned short blue:5;
+ unsigned short alpha:1;
+} pixel_f5551;
+typedef struct {
+ unsigned short red:4;
+ unsigned short green:4;
+ unsigned short blue:4;
+ unsigned short alpha:4;
+} pixel_f4444;
+typedef struct {
+ unsigned char red;
+ unsigned char green;
+ unsigned char blue;
+} pixel_f888;
+
+GLenum
+check_for_glError_and_warn(GLenum expect, char *message)
+{
+ GLenum err;
+
+ err = glGetError();
+ if (expect && !err) {
+ fprintf(stderr, "Expected %x but was not returned: %s\n", expect, message);
+ } else if (err && expect!=0 && expect!=err) {
+ fprintf(stderr, "%s: 0x%04x\n",message, err);
+ }
+ return err;
+}
+
+void
+clear_buffer(void)
+{
+ memset(&buffer, TEST_PATTERN_BYTE, piglit_width*(piglit_height+50)*4);
+}
+
+enum piglit_result
+check_buffer_RGB(void)
+{
+ pixel_f888 *p888;
+ int i,j;
+
+ /* check that the rectangle was rendered correctly */
+ for (i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for (j=piglit_width/4; j<piglit_width/4*3; j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*3));
+ if (p888->red!=0xff && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ /* check that the remaining area is black */
+ for(i=0; i<piglit_height/4; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*3));
+ if (p888->red!=0x00 && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4*3; i<piglit_height; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*3));
+ if (p888->red!=0x00 && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=0; j<piglit_width/4; j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*3));
+ if (p888->red!=0x00 && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=piglit_width/4*3; j<piglit_width; j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*3));
+ if (p888->red!=0x00 && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ return PIGLIT_PASS;
+}
+
+enum piglit_result
+check_buffer_RGBA(void)
+{
+ int i,j;
+
+ /* check that the rectangle was rendered correctly */
+ for (i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for (j=piglit_width/4; j<piglit_width/4*3; j++) {
+ if (buffer[i][j][0]!=0xff && buffer[i][j][1]!=0x00 &&
+ buffer[i][j][2]!=0x00 && buffer[i][j][3]!=0xff)
+ return PIGLIT_FAIL;
+ }
+ }
+ /* check that the remaining area is black */
+ for(i=0; i<piglit_height/4; i++) {
+ for(j=0; j<piglit_width; j++) {
+ if (buffer[i][j][0]!=0x00 && buffer[i][j][1]!=0x00 &&
+ buffer[i][j][2]!=0x00 && buffer[i][j][3]!=0xff)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=(piglit_height/4)*3; i<piglit_height; i++) {
+ for(j=0; j<piglit_width; j++) {
+ if (buffer[i][j][0]!=0x00 && buffer[i][j][1]!=0x00 &&
+ buffer[i][j][2]!=0x00 && buffer[i][j][3]!=0xff)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=0; j<piglit_width/4; j++) {
+ if (buffer[i][j][0]!=0x00 && buffer[i][j][1]!=0x00 &&
+ buffer[i][j][2]!=0x00 && buffer[i][j][3]!=0xff)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=240; j<piglit_width; j++) {
+ if (buffer[i][j][0]!=0x00 && buffer[i][j][1]!=0x00 &&
+ buffer[i][j][2]!=0x00 && buffer[i][j][3]!=0xff)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ return PIGLIT_PASS;
+}
+
+enum piglit_result
+check_buffer_ALPHA(void)
+{
+ GLubyte *alpha=(GLubyte *)buffer;
+ int i,j;
+
+ for(i=0; i<piglit_height; i++) {
+ for(j=0; j<piglit_width; j++) {
+ if (*(alpha+(i*piglit_height)+j)!=0xff)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ return PIGLIT_PASS;
+}
+
+enum piglit_result
+check_buffer_is_not_changed(void)
+{
+ GLubyte *px=(GLubyte *)buffer;
+ int i,j;
+
+ for(i=0; i<piglit_height; i++) {
+ for(j=0; j<(piglit_width+50); j++) {
+ if (*(px+(i*piglit_height)+j)!=TEST_PATTERN_BYTE)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ return PIGLIT_PASS;
+}
+
+enum piglit_result
+check_buffer_RGB_565(void)
+{
+ pixel_f565 *p565;
+ int i,j;
+
+ /* check that the rectangle was rendered correctly */
+ for (i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for (j=piglit_width/4; j<piglit_width/4*3; j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p565->red!=0x1f && p565->blue!=0x00 && p565->green!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ /* check that the remaining area is black */
+ for(i=0; i<piglit_height/4; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p565->red!=0x00 && p565->blue!=0x00 && p565->green!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4*3; i<piglit_height; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p565->red!=0x00 && p565->blue!=0x00 && p565->green!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=0; j<piglit_width/4; j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p565->red!=0x00 && p565->green!=0x00 && p565->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=piglit_width/4*3; j<piglit_width; j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p565->red!=0x00 && p565->green!=0x00 && p565->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ return PIGLIT_PASS;
+}
+
+enum piglit_result
+check_buffer_RGBA_5551(void)
+{
+ pixel_f5551 *p5551;
+ int i,j;
+
+ /* check that the rectangle was rendered correctly */
+ for (i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for (j=piglit_width/4; j<piglit_width/4*3; j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p5551->red!=0x1f && p5551->blue!=0x00 &&
+ p5551->green!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+ /* check that the remaining area is black */
+ for(i=0; i<piglit_height/4; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p5551->red!=0x00 && p5551->green!=0x00 &&
+ p5551->blue!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4*3; i<piglit_height; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p5551->red!=0x00 && p5551->green!=0x00 &&
+ p5551->blue!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=0; j<piglit_width/4; j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p5551->red!=0x00 && p5551->green!=0x00 &&
+ p5551->blue!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=piglit_width/4*3; j<piglit_width; j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p5551->red!=0x00 && p5551->green!=0x00 &&
+ p5551->blue!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ return PIGLIT_PASS;
+}
+
+enum piglit_result
+check_buffer_RGBA_4444(void)
+{
+ pixel_f4444 *p4444;
+ int i,j;
+
+ /* check that the rectangle was rendered correctly */
+ for (i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for (j=piglit_width/4; j<piglit_width/4*3; j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p4444->red!=0xf && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+ /* check that the remaining area is black */
+ for(i=0; i<piglit_height/4; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p4444->red!=0x00 && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4*3; i<piglit_height; i++) {
+ for(j=0; j<piglit_width; j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p4444->red!=0x00 && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=0; j<piglit_width/4; j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p4444->red!=0x00 && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=piglit_height/4; i<piglit_height/4*3; i++) {
+ for(j=piglit_width/4*3; j<piglit_width; j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*piglit_width)+j)*2));
+ if (p4444->red!=0x00 && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+
+ return PIGLIT_PASS;
+}
+
+/* Tests glReadPixels using the following variations
+ * GL_RGBA GL_UNSIGNED_BYTE (different coords)
+ * GL_LUMINANCE GL_UNSIGNED_BYTE
+ * GL_LUMINANCE_ALPHA GL_UNSIGNED_BYTE
+ * GL_DEPTH_COMPONENT GL_UNSIGNED_BYTE
+ * 0x1800 (invalid) GL_UNSIGNED_BYTE
+ * GL_RGBA GL_UNSIGNED_BYTE
+ * GL_RGBA GL_UNSIGNED_SHORT_5_6_5
+ * GL_RGBA GL_UNSIGNED_SHORT_5_5_5_1 (commented out)
+ * GL_RGBA GL_UNSIGNED_SHORT_4_4_4_4
+ * GL_ALPHA GL_UNSIGNED_BYTE
+ * GL_ALPHA GL_UNSIGNED_SHORT_5_6_5 (commented out)
+ * GL_ALPHA GL_UNSIGNED_SHORT_5_5_5_1 (commented out)
+ * GL_ALPHA GL_UNSIGNED_SHORT_4_4_4_4 (commented out)
+ * GL_RGB GL_UNSIGNED_BYTE
+ * GL_RGB GL_UNSIGNED_SHORT_5_6_5
+ * GL_RGB GL_UNSIGNED_SHORT_5_5_5_1
+ * GL_RGB GL_UNSIGNED_SHORT_4_4_4_4 (commented out)
+ */
+
+enum piglit_result
+validate_results()
+{
+ enum piglit_result final_result=PIGLIT_PASS;
+ /* first make sure glError has no issues */
+ if (!piglit_check_gl_error(0))
+ return PIGLIT_FAIL;
+
+ clear_buffer();
+
+ glReadPixels(-10, -10, 10, 10,
+ GL_RGBA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0, "Reading from -10 -10 failed");
+ if (check_buffer_is_not_changed()==PIGLIT_FAIL) {
+ fprintf(stderr, "Reading from -10 -10 for 10x10 should not copy data\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, 0, 0, GL_RGBA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0, "Reading from 0 0 for 0x0 should not copy data");
+ if (check_buffer_is_not_changed()==PIGLIT_FAIL) {
+ fprintf(stderr, "Reading from 0 0 for 0x0 should not copy data\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ glReadPixels(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+ check_for_glError_and_warn(0, "Reading from 0 0 for 1x1 to NULL failed");
+
+ clear_buffer();
+ glReadPixels(0, 0, -10, -10, GL_RGBA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(GL_INVALID_VALUE, "neg width/height should gen GL_INVALID_VALUE");
+ if (check_buffer_is_not_changed()==PIGLIT_FAIL) {
+ fprintf(stderr, "Reading from 0 0 for -10x-10 should not copy data\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ /* according to
+ * http://www.khronos.org/opengles/sdk/docs/man/ glReadPixels
+ * only GL_RGBA, GL_RGB and GL_ALPHA are valid format parameters
+ * GL_LUMINANCE, GL_LUMINANCE_ALPHA and GL_DEPTH_COMPONENT
+ * should fail and return an error
+ */
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_LUMINANCE, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(GL_INVALID_OPERATION, "GL_LUMINANCE should gen GL_INVALID_OPERATION");
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(GL_INVALID_OPERATION, "GL_LUMINANCE_ALPHA should gen GL_INVALID_OPERATION");
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(GL_INVALID_OPERATION, "GL_DEPTH_COMPONENT should gen GL_INVALID_OPERATION");
+
+ /* on mesa currently it incorrectly returns GL_INVALID_VALUE */
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ 0x1800, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(GL_INVALID_OPERATION, "MISC format 0x1800 should gen GL_INVALID_OPERATION");
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_RGBA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0, "GL_RGBA & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_RGBA() == PIGLIT_FAIL) {
+ fprintf(stderr, "GL_RGBA GL_UNSIGNED_BYTE incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_RGBA, GL_UNSIGNED_SHORT_5_6_5, &buffer);
+ check_for_glError_and_warn(GL_INVALID_OPERATION, "GL_RGBA and 565 should gen GL_INVALID_OPERATION");
+
+/* data is returned by this variation however it's incorrect */
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, &buffer);
+ check_for_glError_and_warn(0, "GL_RGBA & GL_UNSIGNED_SHORT 5551 glReadPixels failed");
+ if (check_buffer_RGBA_5551()==PIGLIT_FAIL) {
+ fprintf(stderr, "GL_RGBA GL_UNSIGNED_SHORT 5551 incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, &buffer);
+ check_for_glError_and_warn(0, "GL_RGBA & GL_UNSIGNED_SHORT 4444 glReadPixels failed");
+ if (check_buffer_RGBA_4444()==PIGLIT_FAIL) {
+ fprintf(stderr, "GL_RGBA GL_UNSIGNED_SHORT 4444 incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_ALPHA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0,"GL_ALPHA & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "GL_ALPHA GL_UNSIGNED_BYTE incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ /* data is returned by this variation that is incorrect. */
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height, GL_ALPHA, GL_UNSIGNED_SHORT_5_6_5, &buffer);
+ check_for_glError_and_warn(0, "GL_ALPHA & GL_UNSIGNED_SHORT 565 glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "GL_ALPHA GL_UNSIGNED_BYTE incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height, GL_ALPHA, GL_UNSIGNED_SHORT_5_5_5_1, &buffer);
+ check_for_glError_and_warn(0,"GL_ALPHA & GL_UNSIGNED_SHORT 5551 glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "GL_ALPHA GL_UNSIGNED_SHORT 5551 incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height, GL_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &buffer);
+ check_for_glError_and_warn(0, "GL_ALPHA & GL_UNSIGNED_SHORT 4444 glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "GL_ALPHA GL_UNSIGNED_SHORT 4444 incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_RGB, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0,"GL_RGB & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_RGB() == PIGLIT_FAIL) {
+ fprintf(stderr, "GL_RGB GL_UNSIGNED_BYTE incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height,
+ GL_RGB, GL_UNSIGNED_SHORT_5_6_5, &buffer);
+ check_for_glError_and_warn(0, "GL_RGB & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_RGB_565()==PIGLIT_FAIL) {
+ fprintf(stderr, "GL_RGB GL_UNSIGNED_SHORT 565 incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width,piglit_height,
+ GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, &buffer);
+ check_for_glError_and_warn(0, "GL_RGB & GL_UNSIGNED_SHORT 5551 glReadPixels failed");
+ if (check_buffer_RGBA_5551() == PIGLIT_FAIL) {
+ fprintf(stderr, "GL_RGB GL_UNSIGNED_SHORT 5551 incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ /* this silently fails and doesn't modify the buffer */
+ clear_buffer();
+ glReadPixels(0, 0, piglit_width, piglit_height, GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, &buffer);
+ check_for_glError_and_warn(0, "GL_RGB & GL_UNSIGNED_SHORT 4444 glReadPixels failed");
+ if (check_buffer_RGBA_4444() == PIGLIT_FAIL) {
+ fprintf(stderr, "GL_RGB GL_UNSIGNED_SHORT 4444 incorrect results\n");
+ final_result=PIGLIT_FAIL;
+ }
+
+ piglit_report_result(final_result);
+
+ return final_result;
+}
+
+void
+link_and_use_shaders(void)
+{
+ prog = glCreateProgram();
+
+ vert = piglit_compile_shader_text(GL_VERTEX_SHADER, vertex_shader);
+ frag = piglit_compile_shader_text(GL_FRAGMENT_SHADER, fragment_shader);
+
+ glAttachShader(prog, vert);
+ glAttachShader(prog, frag);
+
+ glLinkProgram(prog);
+ if (!(piglit_link_check_status(prog))) {
+ piglit_report_result(PIGLIT_FAIL);
+ return;
+ }
+
+ glDeleteShader(vert);
+ glDeleteShader(frag);
+
+ glUseProgram(prog);
+ if (!piglit_check_gl_error(0)) {
+ piglit_report_result(PIGLIT_FAIL);
+ return;
+ }
+}
+
+enum piglit_result
+piglit_display(void)
+{
+ GLfloat vertices[] = {
+ 0.5, -0.5, 0.0,
+ 0.5, 0.5, 0.0,
+ -0.5, 0.5, 0.0,
+ -0.5, -0.5, 0.0 };
+
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vertices);
+ glEnableVertexAttribArray(0);
+ glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+ piglit_swap_buffers();
+
+ return validate_results();
+}
+
+void
+piglit_init(int argc, char *argv[])
+{
+ link_and_use_shaders();
+}
--
1.7.10.4
More information about the Piglit
mailing list