[Piglit] [PATCH 2/5] gles2: new glReadPixels unit test
Tom Gall
tom.gall at linaro.org
Mon Dec 17 08:40:25 PST 2012
Unit test for glReadPixels specifically for OpenGL ES 2.0. Covers
a variety of formats and types, both valid and invalid.
A few variations are commented out due to results that are
incorrect and need to be followed up with Mesa, such as modifying
the buffer even tho the format is invalid. There are cases where
the returned data is incorrectly formated. These can best be
addressed in time and I thought it best to include the variations
but in their commented out form.
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 | 631 +++++++++++++++++++++++++
3 files changed, 633 insertions(+)
create mode 100644 tests/spec/gles-2.0/gles2_unit_glReadPixels.c
diff --git a/tests/all.tests b/tests/all.tests
index f8c24b6..e3b1a9e 100644
--- a/tests/all.tests
+++ b/tests/all.tests
@@ -2672,6 +2672,7 @@ egl_khr_create_context['verify GL flavor'] = plain_test('egl-create-context-veri
gles20 = Group()
spec['!OpenGL ES 2.0'] = gles20
gles20['gles2-sanity-test'] = PlainExecTest(['gles2-sanity-test', '-auto'])
+gles20['gles2-unit-glReadPixels'] = PlainExecTest(['gles2-unit-glReadPixels', '-auto'])
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 2c3718d..7cee16c 100644
--- a/tests/spec/gles-2.0/CMakeLists.gles2.txt
+++ b/tests/spec/gles-2.0/CMakeLists.gles2.txt
@@ -6,5 +6,6 @@ link_libraries(
piglit_add_executable(${piglit_target_api}-sanity-test gles2_sanity_test.c)
piglit_add_executable(${piglit_target_api}-invalid-es3-queries invalid-es3-queries.c)
+piglit_add_executable(${piglit_target_api}-unit-glReadPixels 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..4ecc857
--- /dev/null
+++ b/tests/spec/gles-2.0/gles2_unit_glReadPixels.c
@@ -0,0 +1,631 @@
+/*
+ * 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.requires_displayed_window = true;
+
+ config.window_width = WIDTH;
+ config.window_height = HEIGHT;
+ 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, WIDTH*(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=50; i<=149; i++) {
+ for (j=80; j<=239; j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*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<50;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*3));
+ if (p888->red!=0x00 && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=150;i<HEIGHT;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*3));
+ if (p888->red!=0x00 && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=0;j<80;j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*3));
+ if (p888->red!=0x00 && p888->green!=0x00 && p888->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=240;j<WIDTH;j++) {
+ p888=(pixel_f888 *)(((GLubyte *)buffer)+(((i*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=50; i<=149; i++) {
+ for (j=80; j<=239; 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<50;i++) {
+ for(j=0;j<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=150;i<HEIGHT;i++) {
+ for(j=0;j<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=50;i<150;i++) {
+ for(j=0;j<80;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=50;i<150;i++) {
+ for(j=240;j<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<HEIGHT;i++) {
+ for(j=0;j<WIDTH;j++) {
+ if (*(alpha+(i*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<HEIGHT;i++) {
+ for(j=0;j<(WIDTH+50);j++) {
+ if (*(px+(i*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=50; i<=149; i++) {
+ for (j=80; j<=239; j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*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<50;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p565->red!=0x00 && p565->blue!=0x00 &&
+ p565->green!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=150;i<HEIGHT;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p565->red!=0x00 && p565->blue!=0x00 &&
+ p565->green!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=0;j<80;j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p565->red!=0x00 && p565->green!=0x00 &&
+ p565->blue!=0x00)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=240;j<WIDTH;j++) {
+ p565=(pixel_f565 *)(((GLubyte *)buffer)+(((i*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=50; i<=149; i++) {
+ for (j=80; j<=239; j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*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<50;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p5551->red!=0x00 && p5551->green!=0x00 &&
+ p5551->blue!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=150;i<HEIGHT;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p5551->red!=0x00 && p5551->green!=0x00 &&
+ p5551->blue!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=0;j<80;j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p5551->red!=0x00 && p5551->green!=0x00 &&
+ p5551->blue!=0x00 && p5551->alpha!=0x1)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=240;j<WIDTH;j++) {
+ p5551=(pixel_f5551 *)(((GLubyte *)buffer)+(((i*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=50; i<=149; i++) {
+ for (j=80; j<=239; j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*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<50;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p4444->red!=0x00 && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=150;i<HEIGHT;i++) {
+ for(j=0;j<WIDTH;j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p4444->red!=0x00 && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=0;j<80;j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*WIDTH)+j)*2));
+ if (p4444->red!=0x00 && p4444->green!=0x00 &&
+ p4444->blue!=0x00 && p4444->alpha!=0xf)
+ return PIGLIT_FAIL;
+ }
+ }
+ for(i=50;i<150;i++) {
+ for(j=240;j<WIDTH;j++) {
+ p4444=(pixel_f4444 *)(((GLubyte *)buffer)+(((i*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()
+{
+ /* 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");
+ }
+
+ 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");
+ }
+
+ 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");
+ }
+
+ /* 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,WIDTH,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,WIDTH,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,WIDTH,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,WIDTH,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,WIDTH,HEIGHT,GL_RGBA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0,"RGBA & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_RGBA() == PIGLIT_FAIL) {
+ fprintf(stderr, "RGBA GL_UNSIGNED_BYTE incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,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 but it's goofed up
+ commenting out for now, will take issue upstream.
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, &buffer);
+ check_for_glError_and_warn(0,"RGBA & GL_UNSIGNED_SHORT 5551 glReadPixels failed");
+ if (check_buffer_RGBA_5551()==PIGLIT_FAIL) {
+ fprintf(stderr, "RGBA GL_UNSIGNED_SHORT 5551 incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+*/
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4, &buffer);
+ check_for_glError_and_warn(0,"RGBA & GL_UNSIGNED_SHORT 4444 glReadPixels failed");
+ if (check_buffer_RGBA_4444()==PIGLIT_FAIL) {
+ fprintf(stderr, "RGBA GL_UNSIGNED_SHORT 4444 incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_ALPHA, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0,"ALPHA & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "ALPHA GL_UNSIGNED_BYTE incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+ /* data is returned by this variation but it's completely goofed up
+ will take issue upstream.
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_ALPHA, GL_UNSIGNED_SHORT_5_6_5, &buffer);
+ check_for_glError_and_warn(0,"ALPHA & GL_UNSIGNED_SHORT 565 glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "ALPHA GL_UNSIGNED_BYTE incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_ALPHA, GL_UNSIGNED_SHORT_5_5_5_1, &buffer);
+ check_for_glError_and_warn(0,"ALPHA & GL_UNSIGNED_SHORT 5551 glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "ALPHA GL_UNSIGNED_SHORT 5551 incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_ALPHA, GL_UNSIGNED_SHORT_4_4_4_4, &buffer);
+ check_for_glError_and_warn(0,"ALPHA & GL_UNSIGNED_SHORT 4444 glReadPixels failed");
+ if (check_buffer_ALPHA()==PIGLIT_FAIL) {
+ fprintf(stderr, "ALPHA GL_UNSIGNED_SHORT 4444 incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ } */
+
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_RGB, GL_UNSIGNED_BYTE, &buffer);
+ check_for_glError_and_warn(0,"RGB & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_RGB() == PIGLIT_FAIL) {
+ fprintf(stderr, "RGB GL_UNSIGNED_BYTE incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_RGB, GL_UNSIGNED_SHORT_5_6_5, &buffer);
+ check_for_glError_and_warn(0,"RGB & GL_UNSIGNED_BTYE glReadPixels failed");
+ if (check_buffer_RGB_565()==PIGLIT_FAIL) {
+ fprintf(stderr, "RGB GL_UNSIGNED_SHORT 565 incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_RGB, GL_UNSIGNED_SHORT_5_5_5_1, &buffer);
+ check_for_glError_and_warn(0,"RGB & GL_UNSIGNED_SHORT 5551 glReadPixels failed");
+ if (check_buffer_RGBA_5551() == PIGLIT_FAIL) {
+ fprintf(stderr, "RGB GL_UNSIGNED_SHORT 5551 incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+
+/* this silently fails and doesn't modify the buffer
+ clear_buffer();
+ glReadPixels(0,0,WIDTH,HEIGHT,GL_RGB, GL_UNSIGNED_SHORT_4_4_4_4, &buffer);
+ check_for_glError_and_warn(0,"RGB & GL_UNSIGNED_SHORT 4444 glReadPixels failed");
+ if (check_buffer_RGB_4444() == PIGLIT_FAIL) {
+ fprintf(stderr, "RGB GL_UNSIGNED_SHORT 4444 incorrect results\n");
+ piglit_report_result(PIGLIT_WARN);
+ }
+*/
+
+ piglit_report_result(PIGLIT_PASS);
+
+ return PIGLIT_PASS;
+}
+
+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 vVertices[] = { 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, vVertices);
+ 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