[Piglit] [PATCH 10/24] arb_direct_state_access: Tests for glGetTextureImage.

Laura Ekstrand laura at jlekstrand.net
Thu Jan 8 17:08:00 PST 2015


This was a problem that was copied in from the test this was based upon
(getteximage-targets).  I've made a lot of changes to this test for a new
set of patches to mesa, so this will get fixed soon.

On Thu, Jan 8, 2015 at 4:05 PM, Vinson Lee <vlee at freedesktop.org> wrote:

> On Mon, Dec 15, 2014 at 5:24 PM, Laura Ekstrand <laura at jlekstrand.net>
> wrote:
> > ---
> >  tests/all.py                                       |   6 +
> >  .../spec/arb_direct_state_access/CMakeLists.gl.txt |   5 +
> >  tests/spec/arb_direct_state_access/get-textures.c  | 114 +++++
> >  .../gettextureimage-formats.c                      | 559
> +++++++++++++++++++++
> >  .../gettextureimage-luminance.c                    | 260 ++++++++++
> >  .../gettextureimage-simple.c                       |  86 ++++
> >  .../gettextureimage-targets.c                      | 305 +++++++++++
> >  7 files changed, 1335 insertions(+)
> >  create mode 100644 tests/spec/arb_direct_state_access/get-textures.c
> >  create mode 100644
> tests/spec/arb_direct_state_access/gettextureimage-formats.c
> >  create mode 100644
> tests/spec/arb_direct_state_access/gettextureimage-luminance.c
> >  create mode 100644
> tests/spec/arb_direct_state_access/gettextureimage-simple.c
> >  create mode 100644
> tests/spec/arb_direct_state_access/gettextureimage-targets.c
> >
> > diff --git a/tests/all.py b/tests/all.py
> > index 48ec09f..8dfb5ac 100644
> > --- a/tests/all.py
> > +++ b/tests/all.py
> > @@ -4316,6 +4316,12 @@ spec['ARB_direct_state_access']['texunits'] =
> PiglitGLTest('arb_direct_state_acc
> >  spec['ARB_direct_state_access']['texture-params'] =
> PiglitGLTest('arb_direct_state_access-texture-params', run_concurrent=True)
> >  spec['ARB_direct_state_access']['copytexturesubimage'] =
> PiglitGLTest('arb_direct_state_access-copytexturesubimage',
> run_concurrent=True)
> >  spec['ARB_direct_state_access']['texture-errors'] =
> PiglitGLTest('arb_direct_state_access-texture-errors', run_concurrent=True)
> > +spec['ARB_direct_state_access']['get-textures'] =
> PiglitGLTest('arb_direct_state_access-get-textures', run_concurrent=True)
> > +spec['ARB_direct_state_access']['gettextureimage-formats'] =
> PiglitGLTest('arb_direct_state_access-gettextureimage-formats',
> run_concurrent=True)
> > +spec['ARB_direct_state_access']['gettextureimage-luminance'] =
> PiglitGLTest('arb_direct_state_access-gettextureimage-luminance',
> run_concurrent=True)
> > +spec['ARB_direct_state_access']['gettextureimage-simple'] =
> PiglitGLTest('arb_direct_state_access-gettextureimage-simple',
> run_concurrent=True)
> > +spec['ARB_direct_state_access']['gettextureimage-targets'] =
> PiglitGLTest('arb_direct_state_access-gettextureimage-targets',
> run_concurrent=True)
> > +
> >
> >  profile.tests['hiz'] = hiz
> >  profile.tests['fast_color_clear'] = fast_color_clear
> > diff --git a/tests/spec/arb_direct_state_access/CMakeLists.gl.txt
> b/tests/spec/arb_direct_state_access/CMakeLists.gl.txt
> > index 4f8f49f..d5a496e 100644
> > --- a/tests/spec/arb_direct_state_access/CMakeLists.gl.txt
> > +++ b/tests/spec/arb_direct_state_access/CMakeLists.gl.txt
> > @@ -18,4 +18,9 @@ piglit_add_executable
> (arb_direct_state_access-texunits texunits.c)
> >  piglit_add_executable (arb_direct_state_access-texture-params
> texture-params.c)
> >  piglit_add_executable (arb_direct_state_access-copytexturesubimage
> copytexturesubimage.c)
> >  piglit_add_executable (arb_direct_state_access-texture-errors
> texture-errors.c)
> > +piglit_add_executable (arb_direct_state_access-get-textures
> get-textures.c)
> > +piglit_add_executable (arb_direct_state_access-gettextureimage-formats
> gettextureimage-formats.c)
> > +piglit_add_executable
> (arb_direct_state_access-gettextureimage-luminance
> gettextureimage-luminance.c)
> > +piglit_add_executable (arb_direct_state_access-gettextureimage-simple
> gettextureimage-simple.c)
> > +piglit_add_executable (arb_direct_state_access-gettextureimage-targets
> gettextureimage-targets.c)
> >  # vim: ft=cmake:
> > diff --git a/tests/spec/arb_direct_state_access/get-textures.c
> b/tests/spec/arb_direct_state_access/get-textures.c
> > new file mode 100644
> > index 0000000..95d5bc4
> > --- /dev/null
> > +++ b/tests/spec/arb_direct_state_access/get-textures.c
> > @@ -0,0 +1,114 @@
> > +/*
> > + * Copyright 2014 Intel Corporation
> > + *
> > + * 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.
> > + */
> > +
> > +/** @file get-textures.c
> > + *
> > + * Tests glGetTextureImage to see if it behaves in the expected way,
> > + * throwing the correct errors, etc.
> > + */
> > +
> > +#include "piglit-util-gl.h"
> > +
> > +PIGLIT_GL_TEST_CONFIG_BEGIN
> > +
> > +       config.supports_gl_compat_version = 13;
> > +
> > +       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_direct_state_access");
> > +}
> > +
> > +enum piglit_result
> > +piglit_display(void)
> > +{
> > +       bool pass = true;
> > +       GLuint name;
> > +       GLubyte *data = malloc(50 * 50 * 6 * 4 * sizeof(GLubyte));
> > +       GLubyte *image = malloc(50 * 50 * 4 * sizeof(GLubyte));
> > +
> > +       /* Throw some invalid inputs at glGetTextureImage. */
> > +
> > +       /* Non-gen-ed name */
> > +       glGetTextureImage(3, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, data);
> > +       pass &= piglit_check_gl_error(GL_INVALID_OPERATION);
> > +
> > +       /* Unsupported target. */
> > +       glGenTextures(1, &name);
> > +       glBindTexture(GL_TEXTURE_CUBE_MAP_POSITIVE_X, name);
> > +       glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, data);
> > +       pass &= piglit_check_gl_error(GL_INVALID_ENUM);
> > +       glDeleteTextures(1, &name);
> > +
> > +       /* Unsupported dsa target for non-dsa version. */
> > +       glGetTexImage(GL_TEXTURE_CUBE_MAP, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> > +                    data);
> > +       pass &= piglit_check_gl_error(GL_INVALID_ENUM);
> > +
> > +       /* No Storage
> > +        *
> > +        * The spec doesn't say what should happen in this case.  This is
> > +        * addressed by Khronos Bug 13223.
> > +        */
> > +       glCreateTextures(GL_TEXTURE_CUBE_MAP, 1, &name);
> > +       glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, data);
> > +       pass &= piglit_check_gl_error(GL_INVALID_OPERATION);
> > +       glDeleteTextures(1, &name);
> > +
> > +       /* Insufficient storage
> > +        *
> > +        * The spec doesn't say what should happen in this case.  This is
> > +        * addressed by Khronos Bug 13223.
> > +        */
> > +       glCreateTextures(GL_TEXTURE_CUBE_MAP, 1, &name);
> > +       glBindTexture(GL_TEXTURE_CUBE_MAP, name);
> > +       glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, 0,
> > +                    GL_RGBA8, 50, 50, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> image);
> > +       glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, 0,
> > +                    GL_RGBA8, 50, 50, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> image);
> > +       glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, 0,
> > +                    GL_RGBA8, 50, 50, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> image);
> > +       /* Note: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y not set */
> > +       glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, 0,
> > +                    GL_RGBA8, 50, 50, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> image);
> > +       glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, 0,
> > +                    GL_RGBA8, 50, 50, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> image);
> > +       glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0, data);
> > +       pass &= piglit_check_gl_error(GL_INVALID_OPERATION);
> > +       glDeleteTextures(1, &name);
> > +
> > +       /* Trivial, but should work. */
> > +       glCreateTextures(GL_TEXTURE_CUBE_MAP, 1, &name);
> > +       glTextureStorage2D(name, 1, GL_RGBA8, 50, 50);
> > +       glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> > +                         50 * 50 * 6 * 4, data);
> > +       pass &= piglit_check_gl_error(GL_NO_ERROR);
> > +
> > +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > diff --git
> a/tests/spec/arb_direct_state_access/gettextureimage-formats.c
> b/tests/spec/arb_direct_state_access/gettextureimage-formats.c
> > new file mode 100644
> > index 0000000..a22d235
> > --- /dev/null
> > +++ b/tests/spec/arb_direct_state_access/gettextureimage-formats.c
> > @@ -0,0 +1,559 @@
> > +/*
> > + * Copyright (c) 2011 VMware, Inc.
> > + * Copyright (c) 2014 Intel Corporation.
> > + *
> > + * 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 VMWARE 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.
> > + */
> > +
> > +
> > +/**
> > + * @file gettextureimage-formats.c
> > + *
> > + * Test glGetTexImage with a variety of formats.
> > + * Brian Paul
> > + * Sep 2011
> > + *
> > + * Adapted for testing glGetTextureImage in ARB_direct_state_access by
> > + * Laura Ekstrand <laura at jlekstrand.net>, November 2014.
> > + */
> > +
> > +
> > +#include "piglit-util-gl.h"
> > +#include "../fbo/fbo-formats.h"
> > +
> > +PIGLIT_GL_TEST_CONFIG_BEGIN
> > +
> > +       config.supports_gl_compat_version = 10;
> > +
> > +       config.window_width = 600;
> > +       config.window_height = 200;
> > +       config.window_visual = PIGLIT_GL_VISUAL_RGBA |
> PIGLIT_GL_VISUAL_DOUBLE;
> > +
> > +PIGLIT_GL_TEST_CONFIG_END
> > +
> > +static const char *TestName = "gettextureimage-formats";
> > +
> > +static const GLfloat clearColor[4] = { 0.4, 0.4, 0.4, 0.0 };
> > +static GLuint texture_id;
> > +static GLboolean init_by_rendering;
> > +
> > +#define TEX_SIZE 128
> > +
> > +#define DO_BLEND 1
> > +
> > +
> > +/**
> > + * Make a simple texture image where red increases from left to right,
> > + * green increases from bottom to top, blue stays constant (50%) and
> > + * the alpha channel is a checkerboard pattern.
> > + * \return GL_TRUE for success, GL_FALSE if unsupported format
> > + */
> > +static GLboolean
> > +make_texture_image(GLenum intFormat, GLubyte upperRightTexel[4])
> > +{
> > +       GLubyte tex[TEX_SIZE][TEX_SIZE][4];
> > +       int i, j;
> > +       GLuint fb, status;
> > +
> > +       for (i = 0; i < TEX_SIZE; i++) {
> > +               for (j = 0; j < TEX_SIZE; j++) {
> > +                       tex[i][j][0] = j * 255 / TEX_SIZE;
> > +                       tex[i][j][1] = i * 255 / TEX_SIZE;
> > +                       tex[i][j][2] = 128;
> > +                       if (((i >> 4) ^ (j >> 4)) & 1)
> > +                               tex[i][j][3] = 255;  /* opaque */
> > +                       else
> > +                               tex[i][j][3] = 125;     /* transparent */
> > +               }
> > +       }
> > +
> > +       memcpy(upperRightTexel, tex[TEX_SIZE-1][TEX_SIZE-1], 4);
> > +
> > +       if (init_by_rendering) {
> > +               /* Initialize the mipmap levels. */
> > +               for (i = TEX_SIZE, j = 0; i; i >>= 1, j++) {
> > +                       glTexImage2D(GL_TEXTURE_2D, j, intFormat, i, i,
> 0,
> > +                                    GL_RGBA, GL_UNSIGNED_BYTE, NULL);
> > +               }
> > +
> > +               /* Initialize the texture with glDrawPixels. */
> > +               glGenFramebuffers(1, &fb);
> > +               glBindFramebuffer(GL_FRAMEBUFFER, fb);
> > +               glFramebufferTexture2D(GL_FRAMEBUFFER,
> GL_COLOR_ATTACHMENT0,
> > +                                      GL_TEXTURE_2D, texture_id, 0);
> > +               status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
> > +               if (status != GL_FRAMEBUFFER_COMPLETE) {
> > +                       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
> piglit_winsys_fbo);
> > +                       glDeleteFramebuffers(1, &fb);
> > +                       return GL_FALSE;
> > +               }
> > +
> > +               glViewport(0, 0, TEX_SIZE, TEX_SIZE);
> > +
> > +               glWindowPos2iARB(0, 0);
> > +               glDrawPixels(TEX_SIZE, TEX_SIZE, GL_RGBA,
> GL_UNSIGNED_BYTE, tex);
> > +               glGenerateMipmap(GL_TEXTURE_2D);
> > +
> > +               glBindFramebufferEXT(GL_FRAMEBUFFER_EXT,
> piglit_winsys_fbo);
> > +               glDeleteFramebuffers(1, &fb);
> > +               glViewport(0, 0, piglit_width, piglit_height);
> > +       }
> > +       else {
> > +               glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP,
> GL_TRUE);
> > +               glTexImage2D(GL_TEXTURE_2D, 0, intFormat, TEX_SIZE,
> TEX_SIZE, 0,
> > +                            GL_RGBA, GL_UNSIGNED_BYTE, tex);
> > +       }
> > +
> > +       return glGetError() == GL_NO_ERROR;
> > +}
> > +
> > +static GLfloat
> > +ubyte_to_float(GLubyte b, GLint bits)
> > +{
> > +       if (bits <= 8) {
> > +               GLint b2 = b >> (8 - bits);
> > +               GLint max = 255 >> (8 - bits);
> > +               return b2 / (float) max;
> > +       }
> > +       else {
> > +               return b / 255.0;
> > +       }
> > +}
> > +
> > +
> > +
> > +static GLfloat
> > +bits_to_tolerance(GLint bits, GLboolean compressed)
> > +{
> > +       GLfloat t;
> > +
> > +       if (bits == 0) {
> > +               return 0.25;
> > +       }
> > +       else if (bits == 1) {
> > +               return 0.5;
> > +       }
> > +       else if (bits > 8) {
> > +               /* The original texture was specified as GLubyte and we
> > +                * assume that the window/surface is 8-bits/channel.
> > +                */
> > +               t = 4.0 / 255;
> > +       }
> > +       else {
> > +               t = 4.0 / (1 << (bits - 1));
> > +       }
> > +
> > +       if (compressed) {
> > +               /* Use a fudge factor.  The queries for GL_TEXTURE_RED/
> > +                * GREEN/BLUE/ALPHA_SIZE don't return well-defined
> values for
> > +                * compressed formats so using them is unreliable.  This
> is
> > +                * pretty loose, but good enough to catch some Mesa bugs
> during
> > +                * development.
> > +                */
> > +               t = 0.3;
> > +       }
> > +       return t;
> > +}
> > +
> > +
> > +static void
> > +compute_expected_color(const struct format_desc *fmt,
> > +                      const GLubyte upperRightTexel[4],
> > +                      GLfloat expected[4], GLfloat tolerance[4])
> > +{
> > +       GLfloat texel[4];
> > +       GLint compressed;
> > +       int bits[4];
> > +
> > +       bits[0] = bits[1] = bits[2] = bits[3] = 0;
> > +
> > +       /* Handle special cases first */
> > +       if (fmt->internalformat == GL_R11F_G11F_B10F_EXT) {
> > +               bits[0] = bits[1] = bits[2] = 8;
> > +               bits[3] = 0;
> > +               texel[0] = ubyte_to_float(upperRightTexel[0], bits[0]);
> > +               texel[1] = ubyte_to_float(upperRightTexel[1], bits[1]);
> > +               texel[2] = ubyte_to_float(upperRightTexel[2], bits[2]);
> > +               texel[3] = 1.0;
> > +               compressed = GL_FALSE;
> > +       }
> > +       else {
> > +               GLint r, g, b, a, l, i;
> > +               GLenum baseFormat = 0;
> > +
> > +               glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
> GL_TEXTURE_RED_SIZE, &r);
> > +               glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
> GL_TEXTURE_GREEN_SIZE, &g);
> > +               glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
> GL_TEXTURE_BLUE_SIZE, &b);
> > +               glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
> GL_TEXTURE_ALPHA_SIZE, &a);
> > +               glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
> GL_TEXTURE_LUMINANCE_SIZE, &l);
> > +               glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
> GL_TEXTURE_INTENSITY_SIZE, &i);
> > +               glGetTexLevelParameteriv(GL_TEXTURE_2D, 0,
> GL_TEXTURE_COMPRESSED, &compressed);
> > +
> > +               if (0)
> > +                       printf("r=%d g=%d b=%d a=%d l=%d i=%d\n", r, g,
> b, a, l, i);
> > +
> > +               if (i > 0) {
> > +                       baseFormat = GL_INTENSITY;
> > +                       bits[0] = i;
> > +                       bits[1] = 0;
> > +                       bits[2] = 0;
> > +                       bits[3] = i;
> > +                       texel[0] = ubyte_to_float(upperRightTexel[0],
> bits[0]);
> > +                       texel[1] = 0.0;
> > +                       texel[2] = 0.0;
> > +                       texel[3] = ubyte_to_float(upperRightTexel[0],
> bits[3]);
> > +               }
> > +               else if (a > 0) {
> > +                       if (l > 0) {
> > +                               baseFormat = GL_LUMINANCE_ALPHA;
> > +                               bits[0] = l;
> > +                               bits[1] = 0;
> > +                               bits[2] = 0;
> > +                               bits[3] = a;
> > +                               texel[0] =
> ubyte_to_float(upperRightTexel[0], bits[0]);
> > +                               texel[1] = 0.0;
> > +                               texel[2] = 0.0;
> > +                               texel[3] =
> ubyte_to_float(upperRightTexel[3], bits[3]);
> > +                       }
> > +                       else if (r > 0 && g > 0 && b > 0) {
> > +                               baseFormat = GL_RGBA;
> > +                               bits[0] = r;
> > +                               bits[1] = g;
> > +                               bits[2] = b;
> > +                               bits[3] = a;
> > +                               texel[0] =
> ubyte_to_float(upperRightTexel[0], bits[0]);
> > +                               texel[1] =
> ubyte_to_float(upperRightTexel[1], bits[1]);
> > +                               texel[2] =
> ubyte_to_float(upperRightTexel[2], bits[2]);
> > +                               texel[3] =
> ubyte_to_float(upperRightTexel[3], bits[3]);
> > +                       }
> > +                       else if (r == 0 && g == 0 && b == 0) {
> > +                               baseFormat = GL_ALPHA;
> > +                               bits[0] = 0;
> > +                               bits[1] = 0;
> > +                               bits[2] = 0;
> > +                               bits[3] = a;
> > +                               texel[0] = 0.0;
> > +                               texel[1] = 0.0;
> > +                               texel[2] = 0.0;
> > +                               texel[3] =
> ubyte_to_float(upperRightTexel[3], bits[3]);
> > +                       }
> > +                       else {
> > +                               baseFormat = 0;  /* ??? */
> > +                               texel[0] = 0.0;
> > +                               texel[1] = 0.0;
> > +                               texel[2] = 0.0;
> > +                               texel[3] = 0.0;
> > +                       }
> > +               }
> > +               else if (l > 0) {
> > +                       baseFormat = GL_LUMINANCE;
> > +                       bits[0] = l;
> > +                       bits[1] = 0;
> > +                       bits[2] = 0;
> > +                       bits[3] = 0;
> > +                       texel[0] = ubyte_to_float(upperRightTexel[0],
> bits[0]);
> > +                       texel[1] = 0.0;
> > +                       texel[2] = 0.0;
> > +                       texel[3] = 1.0;
> > +               }
> > +               else if (r > 0) {
> > +                       if (g > 0) {
> > +                               if (b > 0) {
> > +                                       baseFormat = GL_RGB;
> > +                                       bits[0] = r;
> > +                                       bits[1] = g;
> > +                                       bits[2] = b;
> > +                                       bits[3] = 0;
> > +                                       texel[0] =
> ubyte_to_float(upperRightTexel[0], bits[0]);
> > +                                       texel[1] =
> ubyte_to_float(upperRightTexel[1], bits[1]);
> > +                                       texel[2] =
> ubyte_to_float(upperRightTexel[2], bits[2]);
> > +                                       texel[3] = 1.0;
> > +                               }
> > +                               else {
> > +                                       baseFormat = GL_RG;
> > +                                       bits[0] = r;
> > +                                       bits[1] = g;
> > +                                       bits[2] = 0;
> > +                                       bits[3] = 0;
> > +                                       texel[0] =
> ubyte_to_float(upperRightTexel[0], bits[0]);
> > +                                       texel[1] =
> ubyte_to_float(upperRightTexel[1], bits[1]);
> > +                                       texel[2] = 0.0;
> > +                                       texel[3] = 1.0;
> > +                               }
> > +                       }
> > +                       else {
> > +                               baseFormat = GL_RED;
> > +                               bits[0] = r;
> > +                               bits[1] = 0;
> > +                               bits[2] = 0;
> > +                               bits[3] = 0;
> > +                               texel[0] =
> ubyte_to_float(upperRightTexel[0], bits[0]);
> > +                               texel[1] = 0.0;
> > +                               texel[2] = 0.0;
> > +                               texel[3] = 1.0;
> > +                       }
> > +               } else {
> > +                       assert(!"Unexpected texture component sizes");
> > +                       texel[0] = 0.0;
> > +                       texel[1] = 0.0;
> > +                       texel[2] = 0.0;
> > +                       texel[3] = 0.0;
> > +               }
> > +
> > +               (void) baseFormat;  /* not used, at this time */
> > +       }
> > +
> > +       /* compute texel color blended with background color */
> > +#if DO_BLEND
> > +       expected[0] = texel[0] * texel[3] + clearColor[0] * (1.0 -
> texel[3]);
> > +       expected[1] = texel[1] * texel[3] + clearColor[1] * (1.0 -
> texel[3]);
> > +       expected[2] = texel[2] * texel[3] + clearColor[2] * (1.0 -
> texel[3]);
> > +       expected[3] = texel[3] * texel[3] + clearColor[3] * (1.0 -
> texel[3]);
> > +#else
> > +        expected[0] = texel[0];
> > +        expected[1] = texel[1];
> > +        expected[2] = texel[2];
> > +        expected[3] = texel[3];
> > +#endif
> > +
> > +       assert(expected[0] == expected[0]);
> > +
> > +       tolerance[0] = bits_to_tolerance(bits[0], compressed);
> > +       tolerance[1] = bits_to_tolerance(bits[1], compressed);
> > +       tolerance[2] = bits_to_tolerance(bits[2], compressed);
> > +       tolerance[3] = bits_to_tolerance(bits[3], compressed);
> > +}
> > +
> > +
> > +static GLboolean
> > +colors_equal(const GLfloat expected[4], const GLfloat pix[4],
> > +            GLfloat tolerance[4])
> > +{
> > +       if (fabsf(expected[0] - pix[0]) > tolerance[0] ||
> > +                fabsf(expected[1] - pix[1]) > tolerance[1] ||
> > +                fabsf(expected[2] - pix[2]) > tolerance[2] ||
> > +                fabsf(expected[3] - pix[3]) > tolerance[3]) {
> > +               return GL_FALSE;
> > +       }
> > +       return GL_TRUE;
> > +}
> > +
> > +
> > +static GLboolean
> > +test_format(const struct test_desc *test,
> > +           const struct format_desc *fmt)
> > +{
> > +       int x, y;
> > +       int w = TEX_SIZE, h = TEX_SIZE;
> > +       GLfloat readback[TEX_SIZE][TEX_SIZE][4];
> > +       GLubyte upperRightTexel[4];
> > +       int level;
> > +       GLfloat expected[4], pix[4], tolerance[4];
> > +       GLboolean pass = GL_TRUE;
> > +
> > +       glClear(GL_COLOR_BUFFER_BIT);
> > +
> > +       /* The RGBA_DXT1 formats seem to expose a Mesa/libtxc_dxtn bug.
> > +        * Just skip them for now.  Testing the other compressed formats
> > +        * is good enough.
> > +        */
> > +       if (fmt->internalformat != GL_COMPRESSED_RGBA_S3TC_DXT1_EXT &&
> > +           fmt->internalformat !=
> GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT) {
> > +               /* init texture image */
> > +               if (!make_texture_image(fmt->internalformat,
> upperRightTexel))
> > +                       return GL_TRUE; /* unsupported = OK */
> > +
> > +               x = 10;
> > +               y = 40;
> > +
> > +               compute_expected_color(fmt, upperRightTexel, expected,
> tolerance);
> > +
> > +               /* Draw with the texture */
> > +               glEnable(GL_TEXTURE_2D);
> > +#if DO_BLEND
> > +               glEnable(GL_BLEND);
> > +#endif
> > +               piglit_draw_rect_tex(x, y, w, h,  0.0, 0.0, 1.0, 1.0);
> > +               glDisable(GL_TEXTURE_2D);
> > +               glDisable(GL_BLEND);
> > +
> > +               x += TEX_SIZE + 20;
> > +
> > +               level = 0;
> > +               while (w > 0) {
> > +                       /* Get the texture image */
> > +                       assert(!glIsEnabled(GL_TEXTURE_2D));
> > +                       glGetTextureImage(texture_id, level, GL_RGBA,
> > +                                         GL_FLOAT, sizeof(readback),
> > +                                         readback);
> > +
> > +                       assert(!glIsEnabled(GL_TEXTURE_2D));
> > +                       /* Draw the texture image */
> > +                       glWindowPos2iARB(x, y);
> > +#if DO_BLEND
> > +                       glEnable(GL_BLEND);
> > +#endif
> > +                       assert(!glIsEnabled(GL_TEXTURE_2D));
> > +                       glDrawPixels(w, h, GL_RGBA, GL_FLOAT, readback);
> > +                       glDisable(GL_BLEND);
> > +
> > +                       assert(!glIsEnabled(GL_TEXTURE_2D));
> > +
> > +                       if (level <= 2) {
> > +                               GLint rx = x + w-1;
> > +                               GLint ry = y + h-1;
> > +                               glReadPixels(rx, ry, 1, 1, GL_RGBA,
> GL_FLOAT, pix);
> > +                               if (!colors_equal(expected, pix,
> tolerance)) {
> > +                                       printf("%s failure: format: %s,
> level %d at pixel(%d, %d)\n",
> > +                                                        TestName,
> fmt->name, level, rx, ry);
> > +                                       printf(" Expected (%f, %f, %f,
> %f)\n",
> > +                                                        expected[0],
> expected[1], expected[2], expected[3]);
> > +                                       printf("         Found (%f, %f,
> %f, %f)\n",
> > +                                                        pix[0], pix[1],
> pix[2], pix[3]);
> > +                                       printf("Tolerance (%f, %f, %f,
> %f)\n",
> > +                                                        tolerance[0],
> tolerance[1], tolerance[2], tolerance[3]);
> > +                                       pass = GL_FALSE;
> > +                               }
> > +                       }
> > +
> > +                       x += w + 20;
> > +                       w /= 2;
> > +                       h /= 2;
> > +                       level++;
> > +               }
> > +
> > +       }
> > +
> > +       piglit_present_results();
> > +
> > +       return pass;
> > +}
> > +
> > +
> > +/**
> > + * Is the given set of formats supported?
> > + * This checks if required extensions are present and if this piglit
> test
> > + * can actually grok the formats.
> > + */
> > +static GLboolean
> > +supported_format_set(const struct test_desc *set)
> > +{
> > +       if (!supported(set))
> > +               return GL_FALSE;
> > +
> > +       if (set->format == ext_texture_integer ||
> > +                set->format == ext_packed_depth_stencil ||
> > +                set->format == arb_texture_rg_int ||
> > +                set->format == arb_depth_texture ||
> > +                set->format == arb_depth_buffer_float) {
> > +               /*
> > +                * texture_integer requires a fragment shader, different
> > +                * glTexImage calls.  Depth/stencil formats not
> implemented.
> > +                */
> > +               return GL_FALSE;
> > +       }
> > +
> > +       return GL_TRUE;
> > +}
> > +
> > +
> > +static GLboolean
> > +test_all_formats(void)
> > +{
> > +       GLboolean pass = GL_TRUE;
> > +       int i, j;
> > +
> > +       for (i = 0; i < ARRAY_SIZE(test_sets); i++) {
> > +               const struct test_desc *set = &test_sets[i];
> > +               if (supported_format_set(set)) {
> > +                       for (j = 0; j < set->num_formats; j++) {
> > +                               if (!test_format(set, &set->format[j])) {
> > +                                       pass = GL_FALSE;
> > +                               }
> > +                       }
> > +               }
> > +       }
> > +
> > +       return pass;
> > +}
> > +
> > +
> > +enum piglit_result
> > +piglit_display(void)
> > +{
> > +       GLboolean pass;
> > +
> > +       piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
> > +
> > +       if (piglit_automatic) {
> > +               pass = test_all_formats();
> > +       }
> > +       else {
> > +               const struct test_desc *set = &test_sets[test_index];
> > +               if (supported_format_set(set)) {
> > +                       pass = test_format(set,
> &set->format[format_index]);
> > +               }
> > +               else {
> > +                       /* unsupported format - not a failure */
> > +                       pass = GL_TRUE;
> > +                       glClear(GL_COLOR_BUFFER_BIT);
> > +                       piglit_present_results();
> > +               }
> > +       }
> > +
> > +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +void
> > +piglit_init(int argc, char **argv)
> > +{
> > +       int i;
> > +
> > +       piglit_require_extension("GL_ARB_direct_state_access");
> > +
> > +       if ((piglit_get_gl_version() < 14) &&
> !piglit_is_extension_supported("GL_ARB_window_pos")) {
> > +               printf("Requires GL 1.4 or GL_ARB_window_pos");
> > +               piglit_report_result(PIGLIT_SKIP);
> > +       }
> > +
> > +       fbo_formats_init(1, argv, !piglit_automatic);
> > +       (void) fbo_formats_display;
> > +
> > +       for (i = 1; i < argc; i++) {
> > +               if (strcmp(argv[i], "init-by-rendering") == 0) {
> > +                       init_by_rendering = GL_TRUE;
> > +                       puts("The textures will be initialized by
> rendering "
> > +                            "to them using glDrawPixels.");
> > +                       break;
> > +               }
> > +       }
> > +
> > +       glGenTextures(1, &texture_id);
> > +       glBindTexture(GL_TEXTURE_2D, texture_id);
> > +       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
> GL_NEAREST);
> > +       glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
> GL_NEAREST);
> > +
> > +       glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
> > +
> > +       glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
> > +
> > +       glClearColor(clearColor[0], clearColor[1], clearColor[2],
> clearColor[3]);
> > +}
> > diff --git
> a/tests/spec/arb_direct_state_access/gettextureimage-luminance.c
> b/tests/spec/arb_direct_state_access/gettextureimage-luminance.c
> > new file mode 100644
> > index 0000000..3add1d7
> > --- /dev/null
> > +++ b/tests/spec/arb_direct_state_access/gettextureimage-luminance.c
> > @@ -0,0 +1,260 @@
> > +/*
> > + * Copyright (c) 2012 VMware, Inc.
> > + * Copyright (c) 2014 Intel Corporation
> > + *
> > + * 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 VMWARE 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.
> > + */
> > +
> > +/*
> > + * Test glGetTexImage for luminance formats.
> > + * Brian Paul
> > + * 8 Mar 2012
> > + *
> > + * Adapted for testing glGetTextureImage in ARB_direct_state_access by
> > + * Laura Ekstrand <laura at jlekstrand.net>, November 2014.
> > + */
> > +
> > +#include "piglit-util-gl.h"
> > +
> > +PIGLIT_GL_TEST_CONFIG_BEGIN
> > +
> > +       config.supports_gl_compat_version = 10;
> > +
> > +       config.window_visual = PIGLIT_GL_VISUAL_RGB |
> PIGLIT_GL_VISUAL_DOUBLE;
> > +
> > +PIGLIT_GL_TEST_CONFIG_END
> > +
> > +static const char *TestName = "gettextureimage-luminance";
> > +static float tolerance = 3.0 / 255.0;
> > +
> > +
> > +static bool
> > +rgba_equal(const float *c1, const float *c2)
> > +{
> > +       return ((fabs(c1[0] - c2[0]) < tolerance) &&
> > +               (fabs(c1[1] - c2[1]) < tolerance) &&
> > +               (fabs(c1[2] - c2[2]) < tolerance) &&
> > +               (fabs(c1[3] - c2[3]) < tolerance));
> > +}
> > +
> > +
> > +static bool
> > +lum_equal(const float *l1, const float *l2)
> > +{
> > +       return fabs(*l1 - *l2) < tolerance;
> > +}
> > +
> > +
> > +/*
> > + * Test reading back a luminance texture as luminance and RGBA.
> > + */
> > +static bool
> > +test_luminance(void)
> > +{
> > +       static const GLfloat lumImage[2*2] = { 0.25, 0.25, 0.25, 0.25 };
> > +       static const GLfloat rgbaImage[4] = { 0.25, 0.0, 0.0, 1.0 };
> > +       GLuint tex;
> > +       GLfloat test[2*2*4];
> > +
> > +       /* create 2x2 GL_LUMINANCE texture */
> > +       glGenTextures(1, &tex);
> > +       glBindTexture(GL_TEXTURE_2D, tex);
> > +       glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 2, 2, 0,
> > +                    GL_LUMINANCE, GL_FLOAT, lumImage);
> > +
> > +       /* Get and check luminance image */
> > +       glGetTextureImage(tex, 0, GL_LUMINANCE, GL_FLOAT, sizeof(test),
> test);
> > +       if (!lum_equal(lumImage, test)) {
> > +               printf("%s: glGetTextureImage(GL_LUMINANCE as"
> > +                      " GL_LUMINANCE) failed\n", TestName);
> > +               printf("  Expected %g  Found %g\n", lumImage[0],
> test[0]);
> > +               return false;
> > +       }
> > +
> > +       /* Get and check rgba image */
> > +       glGetTextureImage(tex, 0, GL_RGBA, GL_FLOAT, sizeof(test),
> &test);
> > +       if (!rgba_equal(rgbaImage, test)) {
> > +               printf("%s: glGetTextureImage(GL_LUMINANCE as"
> > +                      " GL_RGBA) failed\n", TestName);
> > +               printf("  Expected %g, %g, %g, %g  Found %g, %g, %g,
> %g\n",
> > +                      rgbaImage[0], rgbaImage[1], rgbaImage[2],
> rgbaImage[3],
> > +                      test[0], test[1], test[2], test[3]);
> > +               return false;
> > +       }
> > +
> > +       return true;
> > +}
> > +
> > +
> > +/*
> > + * Test reading back an RGBA texture as luminance.
> > + */
> > +static bool
> > +test_rgba(void)
> > +{
> > +       static const GLfloat rgbaImage[4] = { 0.5, 0.25, 0.125, 1.0 };
> > +       static const GLfloat lumImage[1] = { 0.5 };
> > +       GLuint tex;
> > +       GLfloat test[2*2*4];
> > +
> > +       /* create 1x1 GL_RGBA texture */
> > +       glGenTextures(1, &tex);
> > +       glBindTexture(GL_TEXTURE_2D, tex);
> > +       glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0,
> > +                    GL_RGBA, GL_FLOAT, rgbaImage);
> > +
> > +       /* Get and check luminance image */
> > +       glGetTextureImage(tex, 0, GL_LUMINANCE, GL_FLOAT, sizeof(test),
> test);
> > +       if (!lum_equal(lumImage, test)) {
> > +               printf("%s: glGetTextureImage(GL_RGBA as"
> > +                      " GL_LUMINANCE) failed\n", TestName);
> > +               printf("  Expected %g  Found %g\n", lumImage[0],
> test[0]);
> > +               return false;
> > +       }
> > +
> > +       return true;
> > +}
> > +
> > +
> > +/*
> > + * Test reading back a luminance texture via FBO + glReadPixels as RGBA.
> > + */
> > +static bool
> > +test_fbo_readpixels_lum_as_rgba(void)
> > +{
> > +       static const GLfloat lumImage[2*2] = { 0.25, 0.25, 0.25, 0.25 };
> > +       static const GLfloat rgbaImage[4] = { 0.25, 0.0, 0.0, 1.0 };
> > +       GLuint tex, fbo;
> > +       GLfloat test[2*2*4];
> > +       GLenum status;
> > +
> > +       if (!piglit_is_extension_supported("GL_ARB_framebuffer_object"))
> > +               return true;
> > +
> > +       /* create 2x2 GL_LUMINANCE texture */
> > +       glGenTextures(1, &tex);
> > +       glBindTexture(GL_TEXTURE_2D, tex);
> > +       glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 2, 2, 0,
> > +                    GL_LUMINANCE, GL_FLOAT, lumImage);
> > +
> > +       /* create an FBO to wrap the texture so we can read it back
> > +        * with glReadPixels
> > +        */
> > +       glGenFramebuffers(1, &fbo);
> > +       glBindFramebuffer(GL_FRAMEBUFFER, fbo);
> > +       glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0_EXT,
> > +                              GL_TEXTURE_2D, tex, 0);
> > +
> > +       status = glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT);
> > +       if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
> > +               /* can't test glReadPixels from a luminance fbo/texture
> */
> > +               if (!piglit_automatic) {
> > +                       printf("Skipping FBO ReadPixels test\n");
> > +               }
> > +               return true;
> > +       }
> > +
> > +       /* get rgba image (only red should have the lum value) */
> > +       glReadPixels(0, 0, 1, 1, GL_RGBA, GL_FLOAT, test);
> > +       if (!rgba_equal(rgbaImage, test)) {
> > +               printf("%s: glReadPixels(GL_LUMINANCE as GL_RGBA)
> failed\n",
> > +                      TestName);
> > +               printf("  Expected %g, %g, %g, %g  Found %g, %g, %g,
> %g\n",
> > +                      rgbaImage[0], rgbaImage[1], rgbaImage[2],
> rgbaImage[3],
> > +                      test[0], test[1], test[2], test[3]);
> > +               return false;
> > +       }
> > +
> > +       return true;
> > +}
> > +
> > +
> > +/*
> > + * Test reading back an RGBA texture via FBO + glReadPixels as
> luminance.
> > + */
> > +static bool
> > +test_fbo_readpixels_rgba_as_lum(void)
> > +{
> > +       static const GLfloat rgbaImage[4] = { 0.5, 0.25, 0.125, 1.0 };
> > +       static const GLfloat lumImage[1] = { 0.5 + 0.25 + 0.125 };
> > +       GLuint tex, fbo;
> > +       GLfloat test[1];
> > +       GLenum status;
> > +
> > +       if (!piglit_is_extension_supported("GL_ARB_framebuffer_object"))
> > +               return true;
> > +
> > +       /* create 1x1 GL_RGBA texture */
> > +       glGenTextures(1, &tex);
> > +       glBindTexture(GL_TEXTURE_2D, tex);
> > +       glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0,
> > +                    GL_RGBA, GL_FLOAT, rgbaImage);
> > +
> > +       /* create an FBO to wrap the texture so we can read it back
> > +        * with glReadPixels
> > +        */
> > +       glGenFramebuffers(1, &fbo);
> > +       glBindFramebuffer(GL_FRAMEBUFFER, fbo);
> > +       glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0_EXT,
> > +                              GL_TEXTURE_2D, tex, 0);
> > +
> > +       status = glCheckFramebufferStatus(GL_FRAMEBUFFER_EXT);
> > +       if (status != GL_FRAMEBUFFER_COMPLETE_EXT) {
> > +               /* something failed with FBO setup, ignore it */
> > +               if (!piglit_automatic) {
> > +                       printf("Skipping FBO ReadPixels test\n");
> > +               }
> > +               return true;
> > +       }
> > +
> > +       /* get luminance image, should be sum of RGB values */
> > +       glReadPixels(0, 0, 1, 1, GL_LUMINANCE, GL_FLOAT, test);
> > +       if (!lum_equal(lumImage, test)) {
> > +               printf("%s: glReadPixels(GL_RGBA as GL_LUMINANCE)
> failed\n",
> > +                      TestName);
> > +               printf("  Expected %g  Found %g\n", lumImage[0],
> test[0]);
> > +               return false;
> > +       }
> > +
> > +       return true;
> > +}
> > +
> > +
> > +enum piglit_result
> > +piglit_display(void)
> > +{
> > +       bool pass = true;
> > +
> > +       pass = test_luminance() && pass;
> > +       pass = test_rgba() && pass;
> > +       pass = test_fbo_readpixels_lum_as_rgba() && pass;
> > +       pass = test_fbo_readpixels_rgba_as_lum() && pass;
> > +
> > +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +
> > +void
> > +piglit_init(int argc, char **argv)
> > +{
> > +       piglit_require_extension("GL_ARB_direct_state_access");
> > +       piglit_dispatch_default_init(PIGLIT_DISPATCH_GL);
> > +}
> > diff --git a/tests/spec/arb_direct_state_access/gettextureimage-simple.c
> b/tests/spec/arb_direct_state_access/gettextureimage-simple.c
> > new file mode 100644
> > index 0000000..081caaa
> > --- /dev/null
> > +++ b/tests/spec/arb_direct_state_access/gettextureimage-simple.c
> > @@ -0,0 +1,86 @@
> > +/**
> > + * @file gettextureimage-simple.c
> > + *
> > + * Extremely basic test to check whether image data can be retrieved.
> > + *
> > + * Note that the texture is used in a full frame of rendering before
> > + * the readback, to ensure that buffer manager related code for
> uploading
> > + * texture images is executed before the readback.
> > + *
> > + * This used to crash for R300+bufmgr.
> > + *
> > + * Adapted for testing glGetTextureImage in ARB_direct_state_access by
> > + * Laura Ekstrand <laura at jlekstrand.net>, November 2014.
> > + */
> > +
> > +#include "piglit-util-gl.h"
> > +
> > +PIGLIT_GL_TEST_CONFIG_BEGIN
> > +
> > +       config.supports_gl_compat_version = 10;
> > +
> > +       config.window_visual = PIGLIT_GL_VISUAL_RGB |
> PIGLIT_GL_VISUAL_DOUBLE;
> > +
> > +PIGLIT_GL_TEST_CONFIG_END
> > +
> > +static GLubyte data[4096]; /* 64*16*4 */
> > +static GLuint name; /* texture name */
> > +
> > +static int test_getteximage(void)
> > +{
> > +       GLubyte compare[4096];
> > +       int i;
> > +
> > +       glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> > +                         sizeof(compare), compare);
> > +
> > +       for(i = 0; i < 4096; ++i) {
> > +               if (data[i] != compare[i]) {
> > +                       printf("GetTextureImage() returns incorrect data
> in byte %i\n", i);
> > +                       printf("    corresponding to (%i,%i) channel
> %i\n", i / 64, (i / 4) % 16, i % 4);
> > +                       printf("    expected: %i\n", data[i]);
> > +                       printf("    got: %i\n", compare[i]);
> > +                       return 0;
> > +               }
> > +       }
> > +
> > +       return 1;
> > +}
> > +
> > +enum piglit_result
> > +piglit_display(void)
> > +{
> > +       int pass;
> > +
> > +       glClearColor(0.0, 0.0, 0.0, 1.0);
> > +       glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
> > +
> > +       glEnable(GL_TEXTURE_2D);
> > +       glBindTextureUnit(0, name);
> > +       piglit_draw_rect_tex(0, 0, 1, 1, 0, 0, 1, 1);
> > +
> > +       piglit_present_results();
> > +
> > +       pass = test_getteximage();
> > +
> > +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > +void
> > +piglit_init(int argc, char **argv)
> > +{
> > +       int i;
> > +       piglit_require_extension("GL_ARB_direct_state_access");
> > +
> > +       for(i = 0; i < 4096; ++i)
> > +               data[i] = rand() & 0xff;
> > +
> > +       glCreateTextures(GL_TEXTURE_2D, 1, &name);
> > +       glTextureParameteri(name, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
> > +       glTextureParameteri(name, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
> > +       glTextureStorage2D(name, 1, GL_RGBA8, 64, 16);
> > +       glTextureSubImage2D(name, 0, 0, 0, 64, 16, GL_RGBA,
> GL_UNSIGNED_BYTE,
> > +                           data);
> > +
> > +       piglit_gen_ortho_projection(0.0, 1.0, 0.0, 1.0, -2.0, 6.0,
> GL_FALSE);
> > +}
> > diff --git
> a/tests/spec/arb_direct_state_access/gettextureimage-targets.c
> b/tests/spec/arb_direct_state_access/gettextureimage-targets.c
> > new file mode 100644
> > index 0000000..b827a12
> > --- /dev/null
> > +++ b/tests/spec/arb_direct_state_access/gettextureimage-targets.c
> > @@ -0,0 +1,305 @@
> > +/*
> > + * Copyright © 2012 Marek Olšák <maraeo at gmail.com>
> > + * Copyright © 2014 Intel Corporation
> > + *
> > + * 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.
> > + */
> > +
> > +/**
> > + * @file gettextureimage-targets.c
> > + *
> > + * Adapted for testing glGetTextureImage in ARB_direct_state_access by
> > + * Laura Ekstrand <laura at jlekstrand.net>, November 2014.
> > + */
> > +
> > +#include "piglit-util-gl.h"
> > +
> > +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
> > +
> > +#define IMAGE_WIDTH 32
> > +#define IMAGE_HEIGHT 32
> > +#define IMAGE_SIZE (IMAGE_WIDTH * IMAGE_HEIGHT * 4)
> > +
> > +static void
> > +init_layer_data(GLubyte *layer_data, int num_layers)
> > +{
> > +       int x, y, z, i, j;
> > +
> > +       for (z = 0; z < num_layers; z++) {
> > +               GLubyte *data = layer_data + IMAGE_SIZE * z;
> > +
> > +               for (x = 0; x < IMAGE_WIDTH; x += 4) {
> > +                       for (y = 0; y < IMAGE_HEIGHT; y += 4) {
> > +                               int r = (x + 1) * 255 / (IMAGE_WIDTH -
> 1);
> > +                               int g = (y + 1) * 255 / (IMAGE_HEIGHT -
> 1);
> > +                               int b = (z + 1) * 255 / (num_layers - 1);
> > +                               int a = x ^ y ^ z;
> > +
> > +                               /* each 4x4 block constains only one
> color (for S3TC) */
> > +                               for (i = 0; i < 4; i++) {
> > +                                       for (j = 0; j < 4; j++) {
> > +                                               data[((y + j) *
> IMAGE_WIDTH + x
> > +                                                     + i) * 4 + 0] = r;
> > +                                               data[((y + j) *
> IMAGE_WIDTH + x
> > +                                                     + i) * 4 + 1] = g;
> > +                                               data[((y + j) *
> IMAGE_WIDTH + x
> > +                                                     + i) * 4 + 2] = b;
> > +                                               data[((y + j) *
> IMAGE_WIDTH + x
> > +                                                     + i) * 4 + 3] = a;
> > +                                       }
> > +                               }
> > +                       }
> > +               }
> > +       }
> > +}
> > +
> > +static bool
> > +compare_layer(int layer, int num_elements, int tolerance,
> > +                         GLubyte *data, GLubyte *expected)
> > +{
> > +       int i;
> > +
> > +       for (i = 0; i < num_elements; ++i) {
> > +               if (abs((int)data[i] - (int)expected[i]) > tolerance) {
> > +                       printf("GetTextureImage() returns incorrect data
> in byte %i for layer %i\n",
> > +                              i, layer);
> > +                       printf("    corresponding to (%i,%i), channel
> %i\n",
> > +                              (i / 4) / IMAGE_WIDTH, (i / 4) %
> IMAGE_HEIGHT, i % 4);
> > +                       printf("    expected: %i\n", expected[i]);
> > +                       printf("    got: %i\n", data[i]);
> > +                       return false;
> > +               }
> > +       }
> > +       return true;
> > +}
> > +
> > +static bool
> > +getTexImage(bool doPBO, GLenum target, GLubyte data[][IMAGE_SIZE],
> > +           GLenum internalformat, int tolerance)
> > +{
> > +       int i;
> > +       int num_layers=1, num_faces=1, layer_size;
> > +       GLubyte data2[18][IMAGE_SIZE];
> > +       GLubyte *dataGet;
> > +       GLuint packPBO;
> > +       bool pass = true;
> > +       GLuint name;
> > +
> > +       switch (target) {
> > +       case GL_TEXTURE_1D:
> > +               glCreateTextures(target, 1, &name);
> > +               glTextureStorage1D(name, 1, internalformat, IMAGE_WIDTH);
> > +               glTextureSubImage1D(name, 0, 0, IMAGE_WIDTH, GL_RGBA,
> > +                                   GL_UNSIGNED_BYTE, data);
> > +               layer_size = IMAGE_WIDTH * 4;
> > +               break;
> > +
> > +       case GL_TEXTURE_2D:
> > +       case GL_TEXTURE_RECTANGLE:
> > +               glCreateTextures(target, 1, &name);
> > +               glTextureStorage2D(name, 1, internalformat, IMAGE_WIDTH,
> > +                                  IMAGE_HEIGHT);
> > +               glTextureSubImage2D(name, 0, 0, 0, IMAGE_WIDTH,
> IMAGE_HEIGHT,
> > +                                   GL_RGBA, GL_UNSIGNED_BYTE, data);
> > +               layer_size = IMAGE_SIZE;
> > +               break;
> > +
> > +       case GL_TEXTURE_CUBE_MAP:
> > +               num_faces = 6;
> > +               glCreateTextures(target, 1, &name);
> > +               /* This is invalid. You must use 2D storage call for
> cube. */
> > +               glTextureStorage3D(name, 1, internalformat,
> > +                                  IMAGE_WIDTH, IMAGE_HEIGHT, num_faces);
> > +               pass &= piglit_check_gl_error(GL_INVALID_ENUM);
> > +               glTextureStorage2D(name, 1, internalformat,
> > +                                  IMAGE_WIDTH, IMAGE_HEIGHT);
> > +               /* This is legal. */
> > +               glTextureSubImage3D(name, 0, 0, 0, 0, IMAGE_WIDTH,
> > +                                   IMAGE_HEIGHT, num_faces, GL_RGBA,
> > +                                   GL_UNSIGNED_BYTE, data);
> > +               layer_size = IMAGE_SIZE;
> > +               break;
> > +
> > +       case GL_TEXTURE_1D_ARRAY:
> > +               num_layers = 7;
> > +               glCreateTextures(target, 1, &name);
> > +               // test as a single layer 2D image
> > +               glTextureStorage2D(name, 1, internalformat, IMAGE_WIDTH,
> > +                                  num_layers);
> > +               glTextureSubImage2D(name, 0, 0, 0, IMAGE_WIDTH,
> num_layers,
> > +                                   GL_RGBA, GL_UNSIGNED_BYTE, data);
> > +               layer_size = IMAGE_WIDTH * 4 * num_layers;
> > +               num_layers = 1;
> > +               break;
> > +
> > +       case GL_TEXTURE_3D:
> > +               num_layers = 16; /* Fall through. */
> > +       case GL_TEXTURE_2D_ARRAY:
> > +               num_layers = 7; /* Fall through. */
> > +       case GL_TEXTURE_CUBE_MAP_ARRAY:
> > +               num_layers = 6 * 3;
> > +               glCreateTextures(target, 1, &name);
> > +               glTextureStorage3D(name, 1, internalformat, IMAGE_WIDTH,
> > +                                  IMAGE_HEIGHT, num_layers);
> > +               glTextureSubImage3D(name, 0, 0, 0, 0,
> > +                                   IMAGE_WIDTH, IMAGE_HEIGHT,
> num_layers,
> > +                                   GL_RGBA, GL_UNSIGNED_BYTE, data);
> > +               layer_size = IMAGE_SIZE;
> > +               break;
> > +
> > +       default:
> > +               puts("Invalid texture target.");
> > +               return false;
> > +
> > +       }
> > +
> > +       /* Setup the PBO or data array to read into from
> glGetTextureImage */
> > +       if (doPBO) {
> > +               glGenBuffers(1, &packPBO);
> > +               glBindBuffer(GL_PIXEL_PACK_BUFFER, packPBO);
> > +               glBufferData(GL_PIXEL_PACK_BUFFER,
> > +                                    layer_size * num_faces * num_layers,
> > +                                    NULL, GL_STREAM_READ);
> > +       } else {
> > +               glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
> > +               memset(data2, 123, sizeof(data2));
> > +       }
> > +       pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
> > +       assert(num_layers * num_faces * layer_size <= sizeof(data2));
> > +
> > +       if (doPBO) {
> > +               glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> > +                       layer_size * num_faces * num_layers, NULL);
> > +       }
> > +       else {
> > +               glGetTextureImage(name, 0, GL_RGBA, GL_UNSIGNED_BYTE,
> > +                       layer_size * num_faces * num_layers, data2);
> > +       }
> > +       pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
> > +
> > +       if (doPBO)
> > +               dataGet = (GLubyte *) glMapBufferRange(
> > +                                              GL_PIXEL_PACK_BUFFER, 0,
> > +                                              layer_size * num_layers *
> > +                                              num_faces,
> > +                                              GL_MAP_READ_BIT);
> > +       else
> > +               dataGet = data2[0];
> > +
> > +       for (i = 0; i < num_faces * num_layers; i++) {
> > +               pass = compare_layer(i, layer_size, tolerance, dataGet,
> > +                                    data[i]) && pass;
> > +               dataGet += layer_size;
> > +       }
> > +
> > +       if (doPBO) {
> > +               glUnmapBuffer(GL_PIXEL_PACK_BUFFER);
> > +               glDeleteBuffers(1, &packPBO);
> > +       }
> > +
> > +       glDeleteTextures(1, &name);
> > +
> > +       return pass;
> > +}
> > +
> > +struct target_and_mask {
> > +       GLenum target;
> > +       bool mask;
> > +};
> > +
> > +static struct target_and_mask targets[] = {
> > +       {GL_TEXTURE_1D, 1},
> > +       {GL_TEXTURE_2D, 1},
> > +       {GL_TEXTURE_3D, 1},
> > +       {GL_TEXTURE_RECTANGLE, 1},
> > +       {GL_TEXTURE_CUBE_MAP, 1},
> > +       {GL_TEXTURE_1D_ARRAY, 1},
> > +       {GL_TEXTURE_2D_ARRAY, 1},
> > +       {GL_TEXTURE_CUBE_MAP_ARRAY, 1},
> > +};
> > +
> > +static void
> > +clear_target_mask(GLenum target)
> > +{
> > +       int i;
> > +       for (i = 0; i < ARRAY_SIZE(targets); ++i) {
> > +               if (targets[i].target == target) {
> > +                       targets[i].mask = 0;
> > +               }
> > +       }
> > +}
> > +
> > +void
> > +piglit_init(int argc, char **argv)
> > +{
> > +       piglit_require_extension("GL_ARB_direct_state_access");
> > +
> > +       if (piglit_get_gl_version() < 12)
> > +               clear_target_mask(GL_TEXTURE_3D);
> > +       if (!piglit_is_extension_supported("GL_ARB_texture_rectangle"))
> > +               clear_target_mask(GL_TEXTURE_RECTANGLE);
> > +       if (!piglit_is_extension_supported("GL_ARB_texture_cube_map"))
> > +               clear_target_mask(GL_TEXTURE_CUBE_MAP);
> > +       if (!piglit_is_extension_supported("GL_EXT_texture_array")) {
> > +               clear_target_mask(GL_TEXTURE_1D_ARRAY);
> > +               clear_target_mask(GL_TEXTURE_2D_ARRAY);
> > +       }
> > +       if
> (!piglit_is_extension_supported("GL_ARB_texture_cube_map_array"))
> > +               clear_target_mask(GL_TEXTURE_CUBE_MAP_ARRAY);
> > +}
> > +
> > +enum piglit_result
> > +piglit_display(void)
> > +{
> > +       int i;
> > +       bool pass = true;
> > +       GLenum internalformat = GL_RGBA8;
> > +       int tolerance = 0;
> > +       GLubyte data[18][IMAGE_SIZE];
> > +
> > +       init_layer_data(data[0], 18);
> > +
> > +       for (i = 0; i < ARRAY_SIZE(targets); ++i) {
> > +               if (!targets[i].mask)
> > +                       continue;
> > +
> > +               printf("Testing %s into PBO\n",
> > +                       piglit_get_gl_enum_name(targets[i].target));
> > +               pass &= getTexImage(true, targets[i].target, data,
> > +                                   internalformat, tolerance);
> > +
> > +               printf("Testing %s into client array\n",
> > +                       piglit_get_gl_enum_name(targets[i].target));
> > +               pass &= getTexImage(false, targets[i].target, data,
> > +                                   internalformat, tolerance);
> > +
> > +               pass &= piglit_check_gl_error(GL_NO_ERROR);
> > +       }
> > +
> > +       return pass ? PIGLIT_PASS : PIGLIT_FAIL;
> > +}
> > +
> > --
> > 2.1.0
> >
> > _______________________________________________
> > Piglit mailing list
> > Piglit at lists.freedesktop.org
> > http://lists.freedesktop.org/mailman/listinfo/piglit
>
>
> This patch introduced several Coverity unused value defects.
>
> The variable num_layers is assigned and reassigned without being used
> in the fall-through case statements.
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.freedesktop.org/archives/piglit/attachments/20150109/27fa0d21/attachment.html>


More information about the Piglit mailing list