[Piglit] [PATCH 2/3] gl-2.1: Ported pbo test from Glean to Piglit.
Laura Ekstrand
laura at jlekstrand.net
Thu Jan 8 17:00:08 PST 2015
A patch is coming out that fixes these.
On Thu, Jan 8, 2015 at 4:30 PM, Vinson Lee <vlee at freedesktop.org> wrote:
> On Tue, Nov 25, 2014 at 11:19 AM, Laura Ekstrand <laura at jlekstrand.net>
> wrote:
> > ---
> > tests/all.py | 1 +
> > tests/spec/gl-2.1/CMakeLists.gl.txt | 1 +
> > tests/spec/gl-2.1/pbo.c | 1056
> +++++++++++++++++++++++++++++++++++
> > 3 files changed, 1058 insertions(+)
> > create mode 100644 tests/spec/gl-2.1/pbo.c
> >
> > diff --git a/tests/all.py b/tests/all.py
> > index de32fe7..dc3e938 100644
> > --- a/tests/all.py
> > +++ b/tests/all.py
> > @@ -913,6 +913,7 @@ add_concurrent_test(gl20,
> "gl-2.0-active-sampler-conflict")
> > gl21 = {}
> > spec['!OpenGL 2.1'] = gl21
> > gl21['minmax'] = PiglitGLTest('gl-2.1-minmax', run_concurrent=True)
> > +gl21['pbo'] = PiglitGLTest('gl-2.1-pbo', run_concurrent=True)
> >
> > gl30 = {}
> > spec['!OpenGL 3.0'] = gl30
> > diff --git a/tests/spec/gl-2.1/CMakeLists.gl.txt
> b/tests/spec/gl-2.1/CMakeLists.gl.txt
> > index 7e60f1d..f395e32 100644
> > --- a/tests/spec/gl-2.1/CMakeLists.gl.txt
> > +++ b/tests/spec/gl-2.1/CMakeLists.gl.txt
> > @@ -11,3 +11,4 @@ link_libraries (
> > )
> >
> > piglit_add_executable (gl-2.1-minmax minmax.c)
> > +piglit_add_executable (gl-2.1-pbo pbo.c)
> > diff --git a/tests/spec/gl-2.1/pbo.c b/tests/spec/gl-2.1/pbo.c
> > new file mode 100644
> > index 0000000..b6c51e9
> > --- /dev/null
> > +++ b/tests/spec/gl-2.1/pbo.c
> > @@ -0,0 +1,1056 @@
> > +/* BEGIN_COPYRIGHT -*- glean -*-
> > + *
> > + * Copyright (C) 2007, 2014 Intel Corporation
> > + * Copyright (C) 1999 Allen Akin All Rights Reserved.
> > + *
> > + * 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 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.
> > + *
> > + * END_COPYRIGHT
> > + */
> > +
> > +/** @file pbo.c
> > + *
> > + * Test OpenGL Extension GL_ARB_pixel_buffer_object
> > + *
> > + * Authors:
> > + * Shuang He <shuang.he at intel.com>
> > + * Adapted to Piglit by Laura Ekstrand <laura at jlekstrand.net>,
> November 2014.
> > + */
> > +
> > +#include "piglit-util-gl.h"
> > +
> > +#define WINSIZE 100
> > +#define BUFFER_OFFSET(i) ((char *)NULL + (i))
> > +
> > +PIGLIT_GL_TEST_CONFIG_BEGIN
> > +
> > + config.supports_gl_compat_version = 10;
> > +
> > + config.window_visual = PIGLIT_GL_VISUAL_RGBA |
> > + PIGLIT_GL_VISUAL_DOUBLE;
> > +
> > +PIGLIT_GL_TEST_CONFIG_END
> > +
> > +void
> > +piglit_init(int argc, char **argv)
> > +{
> > + piglit_require_extension("GL_ARB_pixel_buffer_object");
> > +
> > + piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
> > +}
> > +
> > +static void
> > +report_failure(const char *msg, const int line)
> > +{
> > + printf("FAILURE: %s (at pbo.c: %d)\n", msg, line);
> > +}
> > +
> > +#define REPORT_FAILURE(MSG) report_failure(MSG, __LINE__)
> > +
> > +#define TEXSIZE 64
> > +
> > +enum piglit_result
> > +test_sanity(void)
> > +{
> > + GLuint pbs[1];
> > + GLuint pb_binding;
> > +
> > + glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING_ARB,
> > + (GLint *) & pb_binding);
> > + if (pb_binding != 0) {
> > + REPORT_FAILURE("Failed to bind unpack pixel buffer
> object");
> > + return PIGLIT_FAIL;
> > + }
> > +
> > + glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB,
> > + (GLint *) & pb_binding);
> > + if (pb_binding != 0) {
> > + REPORT_FAILURE("Failed to bind pack pixel buffer
> object");
> > + return PIGLIT_FAIL;
> > + }
> > +
> > + glGenBuffersARB(1, pbs);
> > +
> > + if (glIsBufferARB(pbs[0]) != GL_FALSE) {
> > + REPORT_FAILURE("glIsBufferARB failed");
> > + return PIGLIT_FAIL;
> > + }
> > +
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pbs[0]);
> > + glGetIntegerv(GL_PIXEL_UNPACK_BUFFER_BINDING_ARB,
> > + (GLint *) & pb_binding);
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + if (pb_binding != pbs[0]) {
> > + REPORT_FAILURE("Failed to bind unpack pixel buffer
> object");
> > + return PIGLIT_FAIL;
> > + }
> > +
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, pbs[0]);
> > + glGetIntegerv(GL_PIXEL_PACK_BUFFER_BINDING_ARB,
> > + (GLint *) & pb_binding);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > + if (pb_binding != pbs[0]) {
> > + REPORT_FAILURE("Failed to bind unpack pixel buffer
> object");
> > + return PIGLIT_FAIL;
> > + }
> > +
> > + glDeleteBuffersARB(1, pbs);
> > +
> > + if (glIsBufferARB(pbs[0]) == GL_TRUE) {
> > + REPORT_FAILURE("glIsBufferARB failed");
> > + return PIGLIT_FAIL;
> > + }
> > +
> > + return PIGLIT_PASS;
> > +}
> > +
> > +enum piglit_result
> > +test_draw_pixels(void)
> > +{
> > + int use_unpack;
> > + int use_pack;
> > + GLuint pb_pack[1];
> > + GLuint pb_unpack[1];
> > + GLubyte buf[WINSIZE * WINSIZE * 4];
> > + GLubyte t[TEXSIZE * TEXSIZE * 4];
> > + int i, j;
> > + GLubyte * pbo_pack_mem = NULL;
> > + GLubyte black[4] = { 0, 0, 0, 255 };
> > + bool pass = true;
> > + GLubyte expected[WINSIZE * WINSIZE * 4];
> > +
> > + glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > +
> > + for (use_unpack = 0; use_unpack < 2; use_unpack++) {
> > + for (use_pack = 0; use_pack < 2; use_pack++) {
> > + GLubyte *pbo_mem = NULL;
> > + glClearColor(0.0, 0.0, 0.0, 1.0);
> > + glClear(GL_COLOR_BUFFER_BIT);
> > + if (use_unpack) {
> > + glGenBuffersARB(1, pb_unpack);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + pb_unpack[0]);
> > +
> glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + TEXSIZE * TEXSIZE * 4 *
> > + sizeof(GLubyte), NULL,
> > + GL_STREAM_DRAW);
> > + }
> > + if (use_unpack) {
> > + pbo_mem = (GLubyte *) glMapBufferARB(
> > +
> GL_PIXEL_UNPACK_BUFFER_ARB,
> > + GL_WRITE_ONLY);
> > + }
> > + else {
> > + pbo_mem = t;
> > + }
> > +
> > + /* Fill the buffer */
> > + for (i = 0; i < TEXSIZE; i++)
> > + for (j = 0; j < TEXSIZE; j++) {
> > + int idx = 4 * (i * TEXSIZE + j);
> > + pbo_mem[idx + 0] = i % 256;
> > + pbo_mem[idx + 1] = i % 256;
> > + pbo_mem[idx + 2] = i % 256;
> > + pbo_mem[idx + 3] = 0;
> > + }
> > +
> > + if (use_unpack) {
> > +
> glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + 0);
> > + }
> > +
> > + /* Draw the buffer */
> > + if (use_unpack) {
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + pb_unpack[0]);
> > + glDrawPixels(TEXSIZE, TEXSIZE, GL_BGRA,
> > + GL_UNSIGNED_BYTE, NULL);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + 0);
> > + }
> > + else {
> > + glDrawPixels(TEXSIZE, TEXSIZE, GL_BGRA,
> > + GL_UNSIGNED_BYTE, pbo_mem);
> > + }
> > +
> > + if (!piglit_automatic)
> > + piglit_present_results();
> > +
> > + /* Check the result */
> > + if (use_pack) {
> > + glGenBuffersARB(1, pb_pack);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + pb_pack[0]);
> > + glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + WINSIZE * WINSIZE * 4 *
> > + sizeof(GL_UNSIGNED_BYTE),
> > + NULL, GL_STREAM_DRAW);
> > + glReadPixels(0, 0, WINSIZE, WINSIZE,
> > + GL_BGRA, GL_UNSIGNED_BYTE,
> NULL);
> > + pbo_pack_mem = (GLubyte *)
> glMapBufferARB(
> > + GL_PIXEL_PACK_BUFFER_ARB,
> > + GL_READ_ONLY);
> > + }
> > + else {
> > + pbo_pack_mem = buf;
> > + glReadPixels(0, 0, WINSIZE, WINSIZE,
> > + GL_BGRA,
> > + GL_UNSIGNED_BYTE,
> pbo_pack_mem);
> > + }
> > +
> > + /* Make expected. */
> > + for (j = 0; j < WINSIZE; j++) {
> > + for (i = 0; i < WINSIZE; i++) {
> > + int idx = (j * WINSIZE + i) * 4;
> > + if (i < TEXSIZE && j < TEXSIZE) {
> > + expected[idx + 0] = j %
> 256;
> > + expected[idx + 1] = j %
> 256;
> > + expected[idx + 2] = j %
> 256;
> > + expected[idx + 3] = 0;
> > + }
> > + else {
> > + expected[idx + 0] =
> black[0];
> > + expected[idx + 1] =
> black[1];
> > + expected[idx + 2] =
> black[2];
> > + expected[idx + 3] =
> black[3];
> > + }
> > + }
> > + }
> > +
> > + pass &= piglit_compare_images_ubyte(0, 0,
> WINSIZE,
> > + WINSIZE,
> > + expected,
> > +
> pbo_pack_mem);
> > +
> > + if (use_pack) {
> > + glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB,
> 0);
> > + glDeleteBuffersARB(1, pb_pack);
> > + }
> > +
> > + if (use_unpack) {
> > + glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB,
> 0);
> > + glDeleteBuffersARB(1, pb_unpack);
> > + }
> > +
> > + }
> > + }
> > +
> > + return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +
> > +enum piglit_result
> > +test_pixel_map(void)
> > +{
> > + int use_unpack;
> > + int use_pack;
> > + GLuint pb_pack[1];
> > + GLuint pb_unpack[1];
> > + int i;
> > + int size;
> > + int max;
> > + GLushort *pbo_mem;
> > +
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > +
> > + glGetIntegerv(GL_MAX_PIXEL_MAP_TABLE, &max);
> > +
> > + for (use_pack = 0; use_pack < 2; use_pack++) {
> > + for (use_unpack = 0; use_unpack < 2;
> > + use_unpack++) {
> > + glClearColor(0.0, 0.0, 0.0, 1.0);
> > + glClear(GL_COLOR_BUFFER_BIT);
> > + if (use_unpack) {
> > + glGenBuffersARB(1, pb_unpack);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + pb_unpack[0]);
> > +
> glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + max * sizeof(GLushort),
> NULL,
> > + GL_STREAM_DRAW);
> > + }
> > + pbo_mem = NULL;
> > + if (use_unpack) {
> > + pbo_mem = (GLushort *) glMapBufferARB(
> > +
> GL_PIXEL_UNPACK_BUFFER_ARB,
> > + GL_WRITE_ONLY);
> > + }
> > + else {
> > + pbo_mem = (GLushort *)
> > + malloc(sizeof(GLushort) * max);
> > + }
> > + for (i = 0; i < max; i++)
> > + pbo_mem[i] = max - i - 1;
> > +
> > + if (use_unpack) {
> > +
> glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
> > + glPixelMapusv(GL_PIXEL_MAP_R_TO_R, max,
> NULL);
> > + glPixelMapusv(GL_PIXEL_MAP_G_TO_G, max,
> NULL);
> > + glPixelMapusv(GL_PIXEL_MAP_B_TO_B, max,
> NULL);
> > + glPixelMapusv(GL_PIXEL_MAP_A_TO_A, max,
> NULL);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + 0);
> > + }
> > + else {
> > + glPixelMapusv(GL_PIXEL_MAP_R_TO_R, max,
> > + pbo_mem);
> > + glPixelMapusv(GL_PIXEL_MAP_G_TO_G, max,
> > + pbo_mem);
> > + glPixelMapusv(GL_PIXEL_MAP_B_TO_B, max,
> > + pbo_mem);
> > + glPixelMapusv(GL_PIXEL_MAP_A_TO_A, max,
> > + pbo_mem);
> > + free(pbo_mem);
> > + }
> > +
> > +
> > + glGetIntegerv(GL_PIXEL_MAP_R_TO_R_SIZE, &size);
> > + if (size != max) {
> > + REPORT_FAILURE("glPixelMap failed");
> > + return PIGLIT_FAIL;
> > + }
> > + glPixelTransferi(GL_MAP_COLOR, GL_FALSE);
> > +
> > + /* Read back pixel map */
> > + if (use_pack) {
> > + glGenBuffersARB(1, pb_pack);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + pb_pack[0]);
> > + glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + max * sizeof(GLushort),
> > + NULL, GL_STREAM_DRAW);
> > + glGetPixelMapusv(GL_PIXEL_MAP_R_TO_R,
> NULL);
> > + pbo_mem = (GLushort *) glMapBufferARB(
> > + GL_PIXEL_PACK_BUFFER_ARB,
> > + GL_READ_ONLY);
> > + }
> > + else {
> > + pbo_mem = (GLushort *)
> > + malloc(sizeof(GLushort) * max);
> > + glGetPixelMapusv(GL_PIXEL_MAP_R_TO_R,
> pbo_mem);
> > + }
> > +
> > + for (i = 0; i < max; i++) {
> > + if (pbo_mem[i] != (255 - i)) {
> > + REPORT_FAILURE("get PixelMap
> failed");
> > + return PIGLIT_FAIL;
> > + }
> > + }
> > +
> > +
> > + if (use_pack) {
> > +
> glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
> > +
> glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > + glDeleteBuffersARB(1, pb_pack);
> > + }
> > + else {
> > + free(pbo_mem);
> > + }
> > +
> > + if (use_unpack) {
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + 0);
> > + glDeleteBuffersARB(1, pb_unpack);
> > + }
> > +
> > + if (!piglit_automatic)
> > + piglit_present_results();
> > +
> > + }
> > + }
> > +
> > + return PIGLIT_PASS;
> > +}
> > +
> > +enum piglit_result
> > +test_bitmap(void)
> > +{
> > + GLuint pb_unpack[1];
> > + GLuint pb_pack[1];
> > + int use_unpack = 1;
> > + int use_pack = 0;
> > + GLubyte bitmap[TEXSIZE * TEXSIZE / 8];
> > + GLfloat buf[WINSIZE * WINSIZE * 3];
> > + GLfloat white[3] = { 1.0, 1.0, 1.0 };
> > + GLfloat black[3] = { 0.0, 0.0, 0.0 };
> > + int i, j;
> > + GLubyte *pbo_unpack_mem = NULL;
> > + GLfloat *pbo_pack_mem = NULL;
> > + GLfloat expected[WINSIZE * WINSIZE * 3];
> > + float tolerance[4];
> > + bool pass = true;
> > +
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > +
> > + for (use_pack = 0; use_pack < 2; use_pack++) {
> > + for (use_unpack = 0; use_unpack < 2;
> > + use_unpack++) {
> > + glClearColor(0.0, 0.0, 0.0, 1.0);
> > + glClear(GL_COLOR_BUFFER_BIT);
> > +
> > + if (use_unpack) {
> > + glGenBuffersARB(1, pb_unpack);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + pb_unpack[0]);
> > +
> glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + TEXSIZE * TEXSIZE,
> > + NULL, GL_STREAM_DRAW);
> > + pbo_unpack_mem = (GLubyte *)
> glMapBufferARB(
> > +
> GL_PIXEL_UNPACK_BUFFER_ARB,
> > + GL_WRITE_ONLY);
> > + }
> > + else {
> > + pbo_unpack_mem = bitmap;
> > + }
> > +
> > + for (i = 0; i < TEXSIZE * TEXSIZE / 8; i++) {
> > + pbo_unpack_mem[i] = 0xAA; /* Binary
> 10101010 */
> > + }
> > +
> > +
> > + glColor4f(1.0, 1.0, 1.0, 0.0);
> > + glRasterPos2f(0.0, 0.0);
> > + if (use_unpack) {
> > +
> glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
> > + /* Draw white into every other pixel,
> > + * for a white/black checkerboard. */
> > + glBitmap(TEXSIZE, TEXSIZE, 0, 0, 0, 0,
> NULL);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + 0);
> > + }
> > + else {
> > + glBitmap(TEXSIZE, TEXSIZE, 0, 0, 0, 0,
> > + pbo_unpack_mem);
> > + }
> > +
> > + if (!piglit_automatic)
> > + piglit_present_results();
> > +
> > + /* Check the result */
> > + if (use_pack) {
> > + glGenBuffersARB(1, pb_pack);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + pb_pack[0]);
> > + glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + WINSIZE * WINSIZE *
> > + 4 * sizeof(GLfloat),
> NULL,
> > + GL_STREAM_DRAW);
> > + glReadPixels(0, 0, WINSIZE, WINSIZE,
> > + GL_RGB, GL_FLOAT,
> > + NULL);
> > + pbo_pack_mem =
> > + (GLfloat *) glMapBufferARB(
> > + GL_PIXEL_PACK_BUFFER_ARB,
> > + GL_READ_ONLY);
> > + }
> > + else {
> > + pbo_pack_mem = buf;
> > + glReadPixels(0, 0, WINSIZE, WINSIZE,
> > + GL_RGB, GL_FLOAT,
> pbo_pack_mem);
> > + }
> > +
> > + /* Compute expected and compare it to the
> result. */
> > + for (j = 0; j < WINSIZE; j++) {
> > + for (i = 0; i < WINSIZE; i++) {
> > + int idx = (j * WINSIZE + i) * 3;
> > + if ((i & 1) || (i >= TEXSIZE) ||
> > + (j >= TEXSIZE)) {
> > + expected[idx + 0] =
> black[0];
> > + expected[idx + 1] =
> black[1];
> > + expected[idx + 2] =
> black[2];
> > + expected[idx + 3] =
> black[3];
> > + }
> > + else {
> > + expected[idx + 0] =
> white[0];
> > + expected[idx + 1] =
> white[1];
> > + expected[idx + 2] =
> white[2];
> > + expected[idx + 3] =
> white[3];
> > + }
> > + }
> > + }
> > + piglit_compute_probe_tolerance(GL_RGB,
> &tolerance[0]);
> > + pass &= piglit_compare_images_color(0, 0,
> WINSIZE,
> > + WINSIZE, 3,
> > + tolerance,
> > + expected,
> > +
> pbo_pack_mem);
> > +
> > + if (use_pack) {
> > + glUnmapBuffer(GL_PIXEL_PACK_BUFFER_ARB);
> > + glBindBuffer(GL_PIXEL_PACK_BUFFER_ARB,
> 0);
> > + glDeleteBuffersARB(1, pb_pack);
> > + }
> > +
> > + if (use_unpack) {
> > + glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB,
> 0);
> > + glDeleteBuffersARB(1, pb_unpack);
> > + }
> > + }
> > + }
> > + return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +
> > +enum piglit_result
> > +test_tex_image(void)
> > +{
> > + bool pass = true;
> > +
> > + int break_pbo_cow, break_tex_cow; /* cow = copy on write */
> > + int use_unpack, use_pack;
> > + GLuint unpack_pb[1];
> > + GLuint pack_pb[1];
> > + GLenum pack = GL_PIXEL_PACK_BUFFER_ARB;
> > + GLenum unpack = GL_PIXEL_UNPACK_BUFFER_ARB;
> > + int texture_size = TEXSIZE * TEXSIZE * 3;
> > + GLfloat t1[texture_size];
> > + GLfloat t2[texture_size];
> > + GLfloat *pbo_mem = NULL;
> > + int i, j;
> > + GLfloat green[3] = { 1.0, 1.0, 0.0 };
> > + GLfloat black[3] = { 0.0, 0.0, 0.0 };
> > + int window_size = WINSIZE * WINSIZE * 3;
> > + GLfloat buf[window_size];
> > + GLfloat exp_tex[texture_size];
> > + GLfloat exp_win[window_size];
> > + GLfloat tolerance[4];
> > +
> > + piglit_compute_probe_tolerance(GL_RGB, tolerance);
> > +
> > + glBindBufferARB(unpack, 0);
> > + glBindBufferARB(pack, 0);
> > +
> > + glClearColor(0.0, 0.0, 0.0, 1.0);
> > + glClear(GL_COLOR_BUFFER_BIT);
> > +
> > + for (use_pack = 0; use_pack < 2; use_pack++) {
> > + for (use_unpack = 0; use_unpack < 2;
> > + use_unpack++) {
> > + for (break_pbo_cow = 0; break_pbo_cow <
> use_unpack + 1;
> > + break_pbo_cow++) {
> > + for (break_tex_cow = 0;
> > + break_tex_cow < use_unpack + 1;
> > + break_tex_cow++) {
> > + if (use_unpack) {
> > + glGenBuffersARB(1,
> unpack_pb);
> > + glBindBufferARB(unpack,
> > + unpack_pb[0]);
> > + glBufferDataARB(unpack,
> > + texture_size *
> > + sizeof(GLfloat),
> > + NULL,
> GL_STREAM_DRAW);
> > + }
> > +
> > + glTexParameteri(GL_TEXTURE_2D,
> > +
> GL_TEXTURE_MIN_FILTER,
> > + GL_NEAREST);
> > + glTexParameteri(GL_TEXTURE_2D,
> > +
> GL_TEXTURE_MAG_FILTER,
> > + GL_NEAREST);
> > +
> > + if (use_unpack) {
> > + pbo_mem = (GLfloat *)
> > +
> glMapBufferARB(unpack,
> > + GL_WRITE_ONLY);
> > + }
> > + else {
> > + pbo_mem = t1;
> > + }
> > +
> > + for (i = 0; i < texture_size/3;
> i++) {
> > + pbo_mem[3 * i] = 1.0;
> > + pbo_mem[3 * i + 1] = 1.0;
> > + pbo_mem[3 * i + 2] = 0.0;
> > + }
> > +
> > + if (use_unpack) {
> > + glUnmapBufferARB(unpack);
> > +
> glTexImage2D(GL_TEXTURE_2D, 0,
> > + GL_RGB,
> TEXSIZE,
> > + TEXSIZE, 0,
> > + GL_RGB,
> GL_FLOAT,
> > + NULL);
> > + glBindBufferARB(unpack,
> 0);
> > + }
> > + else
> > +
> glTexImage2D(GL_TEXTURE_2D, 0,
> > + GL_RGB,
> TEXSIZE,
> > + TEXSIZE, 0,
> > + GL_RGB,
> GL_FLOAT,
> > + pbo_mem);
> > +
> > + if (use_unpack && break_pbo_cow)
> {
> > + glBindBufferARB(unpack,
> > +
> unpack_pb[0]);
> > + pbo_mem = (GLfloat *)
> > + glMapBufferARB(
> > + unpack,
> > +
> GL_WRITE_ONLY);
> > + for (i = 0; i <
> texture_size; i++)
> > + pbo_mem[i] = 0.2;
> > + glUnmapBufferARB(unpack);
> > + glBindBufferARB(unpack,
> 0);
> > + }
> > +
> > + if (use_unpack && break_tex_cow)
> {
> > + GLfloat temp[3];
> > + for (i = 0; i < 3; i++)
> > + temp[i] = 0.8;
> > +
> glTexSubImage2D(GL_TEXTURE_2D,
> > + 0, 0, 0,
> 1, 1,
> > + GL_RGB,
> > + GL_FLOAT,
> > + temp);
> > + }
> > +
> > + /* Check PBO's content */
> > + if (use_unpack) {
> > + glBindBufferARB(unpack,
> > +
> unpack_pb[0]);
> > + pbo_mem = (GLfloat *)
> > +
> glMapBuffer(unpack,
> > + GL_READ_ONLY);
> > + if (break_pbo_cow) {
> > + for (i = 0; i <
> texture_size; i++)
> > + if
> (fabsf(pbo_mem[i] - 0.2) > tolerance[0]) {
> > +
> REPORT_FAILURE
> > +
> ("PBO modified by someone else, "
> > +
> "there must be something wrong");
> > +
> return PIGLIT_FAIL;
> > + }
> > + }
> > + glUnmapBufferARB(unpack);
> > + glBindBufferARB(unpack,
> 0);
> > + }
> > +
> > +
> > + /* Read texture back */
> > + if (use_pack) {
> > + glGenBuffersARB(1,
> pack_pb);
> > + glBindBufferARB(pack,
> pack_pb[0]);
> > + glBufferDataARB(pack,
> > +
> texture_size *
> > +
> sizeof(GLfloat),
> > + NULL,
> GL_STREAM_DRAW);
> > +
> glGetTexImage(GL_TEXTURE_2D,
> > + 0, GL_RGB,
> > + GL_FLOAT,
> NULL);
> > + pbo_mem = (GLfloat *)
> > +
> glMapBufferARB(pack,
> > + GL_READ_ONLY);
> > + }
> > + else {
> > +
> glGetTexImage(GL_TEXTURE_2D,
> > + 0, GL_RGB,
> > + GL_FLOAT,
> t2);
> > + pbo_mem = t2;
> > + }
> > +
> > + /* Check texture image */
> > + for (i = 0; i < texture_size/3;
> i++) {
> > + int idx = i * 3;
> > + if (i == 0 &&
> break_tex_cow
> > + && use_unpack) {
> > + exp_tex[idx + 0]
> = 0.8;
> > + exp_tex[idx + 1]
> = 0.8;
> > + exp_tex[idx + 2]
> = 0.8;
> > + }
> > + else {
> > + exp_tex[idx + 0]
> = 1.0;
> > + exp_tex[idx + 1]
> = 1.0;
> > + exp_tex[idx + 2]
> = 0.0;
> > + }
> > + }
> > + pass &=
> piglit_compare_images_color(0,
> > + 0, TEXSIZE,
> > + TEXSIZE, 3,
> > + tolerance,
> exp_tex,
> > + pbo_mem);
> > +
> > + if (use_pack) {
> > + glUnmapBufferARB(pack);
> > + glBindBufferARB(pack, 0);
> > + glDeleteBuffersARB(1,
> pack_pb);
> > + }
> > + if (use_unpack) {
> > + glDeleteBuffersARB(1,
> unpack_pb);
> > + }
> > +
> > + glEnable(GL_TEXTURE_2D);
> > + glBegin(GL_POLYGON);
> > + glTexCoord2f(0, 0);
> > + glVertex2f(0, 0);
> > + glTexCoord2f(1, 0);
> > + glVertex2f(TEXSIZE, 0);
> > + glTexCoord2f(1, 1);
> > + glVertex2f(TEXSIZE, TEXSIZE);
> > + glTexCoord2f(0, 1);
> > + glVertex2f(0, TEXSIZE);
> > + glEnd();
> > + glDisable(GL_TEXTURE_2D);
> > +
> > + glReadPixels(0, 0, WINSIZE,
> WINSIZE,
> > + GL_RGB, GL_FLOAT,
> > + buf);
> > +
> > + for (j = 0; j < WINSIZE; j++) {
> > + for (i = 0; i < WINSIZE;
> i++) {
> > + int idx = (j *
> WINSIZE + i) * 3;
> > + if (i == 0 && j
> == 0
> > + &&
> break_tex_cow
> > + &&
> use_unpack) {
> > +
> exp_win[idx + 0] = 0.8;
> > +
> exp_win[idx + 1] = 0.8;
> > +
> exp_win[idx + 2] = 0.8;
> > + }
> > + else if (i <
> TEXSIZE && j < TEXSIZE) {
> > +
> exp_win[idx + 0] = green[0];
> > +
> exp_win[idx + 1] = green[1];
> > +
> exp_win[idx + 2] = green[2];
> > + }
> > + else {
> > +
> exp_win[idx + 0] = black[0];
> > +
> exp_win[idx + 1] = black[1];
> > +
> exp_win[idx + 2] = black[2];
> > + }
> > + }
> > + }
> > + pass &=
> piglit_compare_images_color(0,
> > + 0, WINSIZE,
> > + WINSIZE, 3,
> > + tolerance,
> exp_win,
> > + buf);
> > + }
> > + }
> > + }
> > + }
> > +
> > + return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +enum piglit_result
> > +test_tex_sub_image(void)
> > +{
> > + GLuint pbs[1];
> > + GLfloat t[TEXSIZE * TEXSIZE * 3];
> > + int i, j;
> > + int use_unpack = 0;
> > + GLfloat green[3] = { 0.0, 1.0, 0.0 };
> > + GLfloat black[3] = { 0.0, 0.0, 0.0 };
> > + GLfloat *pbo_mem = NULL;
> > + GLfloat buf[WINSIZE * WINSIZE * 3];
> > + bool pass = true;
> > + GLfloat expected[WINSIZE * WINSIZE * 3];
> > + GLfloat tolerance[4];
> > + piglit_compute_probe_tolerance(GL_RGB, &tolerance[0]);
> > +
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > +
> > + for (use_unpack = 0; use_unpack < 2; use_unpack++) {
> > + pbo_mem = NULL;
> > + glClearColor(0.0, 0.0, 0.0, 1.0);
> > + glClear(GL_COLOR_BUFFER_BIT);
> > +
> > + if (use_unpack) {
> > + glGenBuffersARB(1, pbs);
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> pbs[0]);
> > + glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + TEXSIZE * TEXSIZE * 3 *
> > + sizeof(GLfloat), NULL,
> GL_STREAM_DRAW);
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + }
> > +
> > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
> GL_NEAREST);
> > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
> GL_NEAREST);
> > + glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TEXSIZE, TEXSIZE,
> 0, GL_RGB,
> > + GL_FLOAT, NULL);
> > +
> > + if (use_unpack) {
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> pbs[0]);
> > + pbo_mem = (GLfloat *) glMapBufferARB(
> > + GL_PIXEL_UNPACK_BUFFER_ARB,
> > + GL_WRITE_ONLY);
> > + }
> > + else {
> > + pbo_mem = t;
> > + }
> > +
> > + for (i = 0; i < TEXSIZE * TEXSIZE; i++) {
> > + pbo_mem[3 * i] = 0.0;
> > + pbo_mem[3 * i + 1] = 1.0;
> > + pbo_mem[3 * i + 2] = 0.0;
> > + }
> > +
> > + if (use_unpack) {
> > + glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
> > + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, TEXSIZE,
> > + TEXSIZE, GL_RGB, GL_FLOAT, NULL);
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + }
> > + else
> > + glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, TEXSIZE,
> > + TEXSIZE, GL_RGB, GL_FLOAT,
> pbo_mem);
> > +
> > + glEnable(GL_TEXTURE_2D);
> > + glBegin(GL_POLYGON);
> > + glTexCoord2f(0, 0);
> > + glVertex2f(0, 0);
> > + glTexCoord2f(1, 0);
> > + glVertex2f(10, 0);
> > + glTexCoord2f(1, 1);
> > + glVertex2f(10, 10);
> > + glTexCoord2f(0, 1);
> > + glVertex2f(0, 10);
> > + glEnd();
> > + glDisable(GL_TEXTURE_2D);
> > +
> > + glReadPixels(0, 0, WINSIZE, WINSIZE, GL_RGB, GL_FLOAT,
> buf);
> > +
> > + for (j = 0; j < WINSIZE; j++) {
> > + for (i = 0; i < WINSIZE; i++) {
> > + int idx = (j * WINSIZE + i) * 3;
> > + if (i < 10 && j < 10) {
> > + expected[idx + 0] = green[0];
> > + expected[idx + 1] = green[1];
> > + expected[idx + 2] = green[2];
> > + }
> > + else {
> > + expected[idx + 0] = black[0];
> > + expected[idx + 1] = black[1];
> > + expected[idx + 2] = black[2];
> > + }
> > + }
> > + }
> > + pass &= piglit_compare_images_color(0, 0, WINSIZE,
> > + WINSIZE, 3,
> tolerance,
> > + expected, buf);
> > + }
> > +
> > + return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +enum piglit_result
> > +test_polygon_stip(void)
> > +{
> > + int use_unpack = 0;
> > + int use_pack = 0;
> > + GLuint unpack_pb[1];
> > + GLuint pack_pb[1];
> > + GLubyte t1[32 * 32 / 8];
> > + GLubyte t2[32 * 32 / 8];
> > + GLubyte *pbo_mem = NULL;
> > + int i, j;
> > + GLfloat white[3] = { 1.0, 1.0, 1.0 };
> > + GLfloat black[3] = { 0.0, 0.0, 0.0 };
> > + GLfloat buf[WINSIZE * WINSIZE * 3];
> > + bool pass = true;
> > + GLfloat expected[WINSIZE * WINSIZE * 3];
> > + GLfloat tolerance[4];
> > +
> > + piglit_compute_probe_tolerance(GL_RGB, &tolerance[0]);
> > +
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > +
> > + for (use_unpack = 0; use_unpack < 2; use_unpack++) {
> > + for (use_pack = 0; use_pack < 2; use_pack++) {
> > + glClearColor(0.0, 0.0, 0.0, 1.0);
> > + glClear(GL_COLOR_BUFFER_BIT);
> > +
> > + if (use_unpack) {
> > + glGenBuffersARB(1, unpack_pb);
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + unpack_pb[0]);
> > +
> glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
> > + 32 * 32 / 8, NULL,
> > + GL_STREAM_DRAW);
> > + pbo_mem = (GLubyte *) glMapBufferARB(
> > +
> GL_PIXEL_UNPACK_BUFFER_ARB,
> > + GL_WRITE_ONLY);
> > + }
> > + else {
> > + pbo_mem = t1;
> > + }
> > +
> > + /* Fill in the stipple pattern */
> > + for (i = 0; i < 32 * 32 / 8; i++) {
> > + pbo_mem[i] = 0xAA; /* Checkerboard */
> > + }
> > +
> > + if (use_unpack) {
> > +
> glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB);
> > + glPolygonStipple(NULL);
> > + }
> > + else {
> > + glPolygonStipple(pbo_mem);
> > + }
> > +
> > + /* Read back the stipple pattern */
> > + if (use_pack) {
> > + glGenBuffersARB(1, pack_pb);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + pack_pb[0]);
> > + glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB,
> > + 32 * 32 / 8, NULL,
> > + GL_STREAM_DRAW);
> > + glGetPolygonStipple(NULL);
> > + pbo_mem = (GLubyte *) glMapBufferARB(
> > + GL_PIXEL_PACK_BUFFER_ARB,
> > + GL_READ_ONLY);
> > + }
> > + else {
> > + glGetPolygonStipple(t2);
> > + pbo_mem = t2;
> > + }
> > +
> > + for (i = 0; i < 32 * 32 / 8; i++) {
> > + if (pbo_mem[i] != 0xAA) {
> > +
> REPORT_FAILURE("glGetPolygonStipple failed");
> > + return PIGLIT_FAIL;
> > + }
> > + }
> > +
> > +
> > + if (use_unpack) {
> > +
> glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + glDeleteBuffersARB(1, unpack_pb);
> > + }
> > + if (use_pack) {
> > +
> glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > + glDeleteBuffersARB(1, pack_pb);
> > + }
> > +
> > + glEnable(GL_POLYGON_STIPPLE);
> > + glColor4f(1.0, 1.0, 1.0, 0.0);
> > + glBegin(GL_POLYGON);
> > + glVertex2f(0, 0);
> > + glVertex2f(10, 0);
> > + glVertex2f(10, 10);
> > + glVertex2f(0, 10);
> > + glEnd();
> > +
> > + glDisable(GL_POLYGON_STIPPLE);
> > +
> > + /* Check the result */
> > + glReadPixels(0, 0, WINSIZE, WINSIZE, GL_RGB,
> GL_FLOAT, buf);
> > +
> > + for (j = 0; j < WINSIZE; j++) {
> > + for (i = 0; i < WINSIZE; i++) {
> > + int idx = (j * WINSIZE + i) * 3;
> > + if (!(i & 1) && i < 10 && j <
> 10) {
> > + expected[idx + 0] =
> white[0];
> > + expected[idx + 1] =
> white[1];
> > + expected[idx + 2] =
> white[2];
> > + }
> > + else {
> > + expected[idx + 0] =
> black[0];
> > + expected[idx + 1] =
> black[1];
> > + expected[idx + 2] =
> black[2];
> > + }
> > + }
> > + }
> > + pass &= piglit_compare_images_color(0, 0,
> WINSIZE,
> > + WINSIZE, 3,
> > + tolerance,
> > + expected,
> buf);
> > +
> > + }
> > + }
> > +
> > + return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +enum piglit_result
> > +test_error_handling(void)
> > +{
> > + GLuint fbs[1];
> > +
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
> > +
> > + /* glDrawPixels raises an error when the buffer is too small */
> > + glGenBuffersARB(1, fbs);
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER, fbs[0]);
> > + glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, 32 * 32 * 4, NULL,
> > + GL_STREAM_DRAW);
> > + glDrawPixels(32, 32 + 1, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
> > + if (glGetError() != GL_INVALID_OPERATION)
> > + return PIGLIT_FAIL;
> > +
> > + glDeleteBuffersARB(1, fbs);
> > + glBindBufferARB(GL_PIXEL_UNPACK_BUFFER, 0);
> > +
> > + /* test that glReadPixels into too small of buffer raises error
> */
> > + glGenBuffersARB(1, fbs);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER, fbs[0]);
> > + glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, 32 * 32 * 4, NULL,
> > + GL_STREAM_DRAW);
> > + glReadPixels(0, 0, 32, 32 + 1, GL_BGRA, GL_UNSIGNED_BYTE, NULL);
> > + if (glGetError() != GL_INVALID_OPERATION)
> > + return PIGLIT_FAIL;
> > +
> > + glDeleteBuffersARB(1, fbs);
> > + glBindBufferARB(GL_PIXEL_PACK_BUFFER, 0);
> > +
> > + return PIGLIT_PASS;
> > +}
> > +
> > +struct test_func {
> > + enum piglit_result (*func) (void);
> > + char *name;
> > +};
> > +
> > +enum piglit_result
> > +piglit_display(void)
> > +{
> > + int i = 0;
> > + enum piglit_result result = PIGLIT_PASS;
> > + enum piglit_result subtest;
> > + static struct test_func funcs[] = {
> > + {test_sanity, "test_sanity"},
> > + {test_draw_pixels, "test_draw_pixels"},
> > + {test_pixel_map, "test_pixel_map"},
> > + {test_bitmap, "test_bitmap"},
> > + {test_tex_image, "test_tex_image"},
> > + {test_tex_sub_image, "test_tex_sub_image"},
> > + {test_polygon_stip, "test_polygon_stip"},
> > + {test_error_handling, "test_error_handling"},
> > + {NULL, ""} /* End of list sentinal */
> > + };
> > +
> > + while (funcs[i].func)
> > + {
> > + subtest = funcs[i].func();
> > + piglit_report_subtest_result(subtest, "%s",
> > + funcs[i].name);
> > + if (subtest == PIGLIT_FAIL)
> > + result = PIGLIT_FAIL;
> > + i++;
> > + }
> > +
> > + return result;
> > +}
> > --
> > 2.1.0
> >
> > _______________________________________________
> > Piglit mailing list
> > Piglit at lists.freedesktop.org
> > http://lists.freedesktop.org/mailman/listinfo/piglit
>
>
> This patch introduced several compiler warnings with GCC and Clang.
>
> pbo.c:484:27: warning: array index 3 is past the end of the array
> (which contains 3 elements) [-Warray-bounds]
> expected[idx + 3] =
> black[3];
> ^ ~
> pbo.c:397:2: note: array 'black' declared here
> GLfloat black[3] = { 0.0, 0.0, 0.0 };
> ^
> pbo.c:490:27: warning: array index 3 is past the end of the array
> (which contains 3 elements) [-Warray-bounds]
> expected[idx + 3] =
> white[3];
> ^ ~
> pbo.c:396:2: note: array 'white' declared here
> GLfloat white[3] = { 1.0, 1.0, 1.0 };
> ^
> pbo.c:529:12: warning: variable length array used [-Wvla]
> GLfloat t1[texture_size];
> ^
> pbo.c:530:12: warning: variable length array used [-Wvla]
> GLfloat t2[texture_size];
> ^
> pbo.c:536:13: warning: variable length array used [-Wvla]
> GLfloat buf[window_size];
> ^
> pbo.c:537:17: warning: variable length array used [-Wvla]
> GLfloat exp_tex[texture_size];
> ^
> pbo.c:538:17: warning: variable length array used [-Wvla]
> GLfloat exp_win[window_size];
> ^
> pbo.c:638:13: warning: absolute value function 'fabsf' given an
> argument of type 'double' but has parameter of type 'float' which may
> cause truncation of value [-Wabsolute-value]
> if
> (fabsf(pbo_mem[i] - 0.2) > tolerance[0]) {
> ^
> pbo.c:638:13: note: use function 'fabs' instead
> if
> (fabsf(pbo_mem[i] - 0.2) > tolerance[0]) {
> ^~~~~
> fabs
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.freedesktop.org/archives/piglit/attachments/20150109/7a3038fb/attachment.html>
More information about the Piglit
mailing list