ext_gpu_shader4: add compiler tests for everything

[piglit.git] / tests / spec / arb_texture_compression / internal-format-query.c

/*
 * Copyright © 2011 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 internal-format-query.c
 * Verify behavior of TEXTURE_INTERNAL_FORMAT for generic compression formats
 *
 * Typically the \c GL_TEXTURE_INTERNAL_FORMAT query returns the internal
 * format specified by the application at \c glTexImage2D time.  This behavior
 * is modified for the generic compressed texture internal formats.
 * Specifically, the issues section of the GL_ARB_texture_compression spec
 * says:
 *
 *    "(10) Should functionality be provided to allow applications to save
 *    compressed images to disk and reuse them in subsequent runs without
 *    programming to specific formats?  If so, how?
 *
 *      RESOLVED:  Yes.  This can be done without knowledge of specific
 *      compression formats in the following manner:
 *
 *        * Call TexImage with an uncompressed image and a generic compressed
 *          internal format.  The texture image will be compressed by the GL, if
 *          possible.
 *
 *        * Call GetTexLevelParameteriv with a <value> of TEXTURE_COMPRESSED_ARB
 *          to determine if the GL was able to store the image in compressed
 *          form.
 *
 *        * Call GetTexLevelParameteriv with a <value> of
 *          TEXTURE_INTERNAL_FORMAT to determine the specific compressed image
 *          format in which the image is stored.
 *
 *        ..."
 *
 * The body of the spec (section 3.8.1, Texture Image Specification) also say:
 *
 *     "Generic compressed internal formats are never used directly as the
 *     internal formats of texture images.  If <internalformat> is one of the
 *     six generic compressed internal formats, its value is replaced by the
 *     symbolic constant for a specific compressed internal format of the GL's
 *     choosing with the same base internal format.  If no specific compressed
 *     format is available, <internalformat> is instead replaced by the
 *     corresponding base internal format.  If <internalformat> is given as or
 *     mapped to a specific compressed internal format, but the GL can not
 *     support images compressed in the chosen internal format for any reason
 *     (e.g., the compression format might not support 3D textures or borders),
 *     <internalformat> is replaced by the corresponding base internal format
 *     and the texture image will not be compressed by the GL."
 */
#include <stdarg.h>
#include "piglit-util-gl.h"

PIGLIT_GL_TEST_CONFIG_BEGIN

        config.supports_gl_compat_version = 10;

        config.window_width = 10;
        config.window_height = 10;
        config.window_visual = PIGLIT_GL_VISUAL_RGB;

PIGLIT_GL_TEST_CONFIG_END

struct test_vector {
        GLenum generic_compressed_format;
        GLenum base_format;
};

/**
 * Generic texture formats in OpenGL 1.3 and GL_ARB_texture_compression.
 */
static const struct test_vector arb_texture_compression_formats[] = {
        {GL_COMPRESSED_ALPHA, GL_ALPHA},
        {GL_COMPRESSED_LUMINANCE, GL_LUMINANCE},
        {GL_COMPRESSED_LUMINANCE_ALPHA, GL_LUMINANCE_ALPHA},
        {GL_COMPRESSED_INTENSITY, GL_INTENSITY},
        {GL_COMPRESSED_RGB, GL_RGB},
        {GL_COMPRESSED_RGBA, GL_RGBA},
};

/**
 * Generic texture formats in OpenGL 3.0 and GL_ARB_texture_rg.
 */
static const struct test_vector arb_texture_rg_formats[] = {
        { GL_COMPRESSED_RED, GL_RED },
        { GL_COMPRESSED_RG, GL_RG },
};

/**
 * Generic texture formats in OpenGL 2.1 and GL_EXT_texture_sRGB.
 */
static const struct test_vector ext_texture_srgb_formats[] = {
        { GL_COMPRESSED_SRGB_EXT, GL_RGB },
        { GL_COMPRESSED_SRGB_ALPHA_EXT, GL_RGBA },
        { GL_COMPRESSED_SLUMINANCE_EXT, GL_LUMINANCE },
        { GL_COMPRESSED_SLUMINANCE_ALPHA_EXT, GL_LUMINANCE_ALPHA },
};

static GLubyte dummy_data[16 * 16 * 4];

enum piglit_result
piglit_display(void)
{
        return PIGLIT_FAIL;
}

GLenum *
add_formats(GLenum *formats, GLint *total, unsigned add, ...)
{
        va_list ap;
        unsigned i;

        formats = realloc(formats, sizeof(GLenum) * (*total + add));

        va_start(ap, add);

        for (i = 0; i < add; i++) {
                formats[*total] = va_arg(ap, GLenum);
                (*total)++;
        }

        va_end(ap);
        return formats;
}

static bool
try_formats(const struct test_vector *t, unsigned num_tests,
            const GLenum *compressed_formats, GLint num_compressed_formats)
{
        bool pass = true;
        unsigned i;

        for (i = 0; i < num_tests; i++) {
                GLuint tex;
                GLint is_compressed;
                GLenum format;
                const char *generic_compressed_format_string =
                                   piglit_get_gl_enum_name(
                                           t[i].generic_compressed_format);

                           if (!piglit_automatic)
                {
                        printf("Trying %s/0x%04x (base format = 0x%04x)...\n",
                               generic_compressed_format_string,
                               t[i].generic_compressed_format,
                               t[i].base_format);
                }

                glGenTextures(1, &tex);
                glBindTexture(GL_TEXTURE_2D, tex);
                glTexImage2D(GL_TEXTURE_2D, 0,
                             t[i].generic_compressed_format,
                             16, 16, 0,
                             /* Remember that GL_INTESITY is not a valid format
                              * for image data.
                              */
                             (t[i].base_format == GL_INTENSITY)
                             ? GL_RGBA : t[i].base_format,
                             GL_UNSIGNED_BYTE,
                             dummy_data);

                glGetTexLevelParameteriv(GL_TEXTURE_2D,
                                         0,
                                         GL_TEXTURE_COMPRESSED,
                                         &is_compressed);

                glGetTexLevelParameteriv(GL_TEXTURE_2D,
                                         0,
                                         GL_TEXTURE_INTERNAL_FORMAT,
                                         (GLint *) &format);

                if (!piglit_automatic) {
                        printf("  is %scompressed, internal format = 0x%04x\n",
                               is_compressed ? "" : "not ",
                               format);
                }

                if (is_compressed) {
                        unsigned j;

                        for (j = 0; j < num_compressed_formats; j++) {
                                if (format == compressed_formats[j])
                                        break;
                        }

                        if (format == t[i].generic_compressed_format) {
                                fprintf(stderr,
                                        "%s did compress, but it got the "
                                        "generic\n"
                                        "format as the specific internal "
                                        "format.\n",
                                        generic_compressed_format_string);
                                pass = false;
                        } else if (format <= 4 || format == t[i].base_format) {
                                fprintf(stderr,
                                        "%s did compress, but it got an "
                                        "internal\n"
                                        "format 0x%04x that is "
                                        "non-compressed\n",
                                        generic_compressed_format_string,
                                        format);
                                pass = false;
                        } else if (j == num_compressed_formats) {
                                fprintf(stderr,
                                        "%s did compress, but it got an "
                                        "internal\n"
                                        "format of %s when "
                                        "one of the supported compressed "
                                        "formats was expected.\n"
                                        "This may just mean the test does not "
                                        "know about the compessed format that\n"
                                        "was selected by the driver.\n",
                                        generic_compressed_format_string,
                                        piglit_get_gl_enum_name(format));
                        }
                } else if (format != t[i].base_format) {
                        if (format == t[i].generic_compressed_format) {
                                fprintf(stderr,
                                        "%s did not compress, but it got the "
                                        "generic\n"
                                        "format as the specific internal "
                                        "format.\n",
                                        generic_compressed_format_string);
                        } else {
                                fprintf(stderr,
                                        "%s did not compress, but it got an "
                                        "internal format of %s when "
                                        "%s was expected.\n",
                                        generic_compressed_format_string,
                                        piglit_get_gl_enum_name(format),
                                        piglit_get_gl_enum_name(t[i].base_format));
                        }

                        pass = false;
                }

                glBindTexture(GL_TEXTURE_2D, 0);
                glDeleteTextures(1, &tex);

                if (!piglit_automatic) {
                        printf("\n");
                }
        }

        return pass;
}

void
piglit_init(int argc, char **argv)
{
        GLint num_compressed_formats;
        GLenum *compressed_formats = NULL;
        unsigned i;
        bool pass = true;

        piglit_require_extension("GL_ARB_texture_compression");

        glGetIntegerv(GL_NUM_COMPRESSED_TEXTURE_FORMATS,
                      &num_compressed_formats);
        if (num_compressed_formats == 0) {
                printf("No compressed formats supported.\n");
        } else if (num_compressed_formats < 0) {
                fprintf(stderr,
                        "Invalid number of compressed formats (%d) reported\n",
                        num_compressed_formats);
                piglit_report_result(PIGLIT_FAIL);
        } else {
                compressed_formats = calloc(num_compressed_formats,
                                            sizeof(GLenum));
                glGetIntegerv(GL_COMPRESSED_TEXTURE_FORMATS,
                              (GLint *) compressed_formats);

                printf("Driver reported the following compressed formats:\n");
                for (i = 0; i < num_compressed_formats; i++) {
                        printf("    0x%04x %s\n",
                               compressed_formats[i],
                               piglit_get_gl_enum_name(compressed_formats[i]));
                }
                printf("\n");
                fflush(stdout);
        }

        /* There are some specific formats that are valid for certain generic
         * formats that are not returned by the GL_COMRPESSED_TEXTURE_FORMATS
         * query.  That query only returns formats that have no restrictions or
         * caveats for RGB or RGBA base formats.  We have to add these formats
         * to the list of possible formats by hand.
         */
        if (piglit_is_extension_supported("GL_EXT_texture_compression_latc")) {
                compressed_formats =
                        add_formats(compressed_formats,
                                    &num_compressed_formats,
                                    4,
                                    GL_COMPRESSED_LUMINANCE_LATC1_EXT,
                                    GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT,
                                    GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT,
                                    GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT);
        }

        if (piglit_is_extension_supported("GL_ATI_texture_compression_3dc")) {
                compressed_formats =
                        add_formats(compressed_formats,
                                    &num_compressed_formats,
                                    1,
                                    0x8837);
        }

        pass = try_formats(arb_texture_compression_formats,
                           ARRAY_SIZE(arb_texture_compression_formats),
                           compressed_formats,
                           num_compressed_formats);

        /* Remove the various luminance and luminance-alpha formats from the
         * list since they cannot be used for the later tests.
         */
        if (piglit_is_extension_supported("GL_ATI_texture_compression_3dc")) {
                num_compressed_formats--;
        }

        if (piglit_is_extension_supported("GL_EXT_texture_compression_latc")) {
                num_compressed_formats -= 4;
        }

        /* Add the RGTC formats, then check them.
         */
        if (piglit_is_extension_supported("GL_ARB_texture_rg")) {
                if (piglit_is_extension_supported("GL_ARB_texture_compression_rgtc")
                    || piglit_is_extension_supported("GL_EXT_texture_compression_rgtc")) {
                        compressed_formats =
                                add_formats(compressed_formats,
                                            &num_compressed_formats,
                                            4,
                                            GL_COMPRESSED_RED_RGTC1,
                                            GL_COMPRESSED_SIGNED_RED_RGTC1,
                                            GL_COMPRESSED_RG_RGTC2,
                                            GL_COMPRESSED_SIGNED_RG_RGTC2);
                }

                pass = try_formats(arb_texture_rg_formats,
                                   ARRAY_SIZE(arb_texture_rg_formats),
                                   compressed_formats,
                                   num_compressed_formats)
                        && pass;

                /* Remove the RGTC formats from the list since they cannot be
                 * used for the later tests.
                 */
                if (piglit_is_extension_supported("GL_ARB_texture_compression_rgtc")
                    || piglit_is_extension_supported("GL_EXT_texture_compression_rgtc")) {
                        num_compressed_formats -= 4;
                }
        }


        /* Add the sRGB formats, then check them.
         */
        if (piglit_is_extension_supported("GL_EXT_texture_sRGB")) {
                compressed_formats =
                        add_formats(compressed_formats,
                                    &num_compressed_formats,
                                    4,
                                    GL_COMPRESSED_SRGB,
                                    GL_COMPRESSED_SRGB_ALPHA,
                                    GL_COMPRESSED_SLUMINANCE,
                                    GL_COMPRESSED_SLUMINANCE_ALPHA);

                if (piglit_is_extension_supported("GL_EXT_texture_compression_s3tc")) {
                        compressed_formats =
                                add_formats(compressed_formats,
                                            &num_compressed_formats,
                                            4,
                                            GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,
                                            GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT,
                                            GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT,
                                            GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT);
                }

                pass = try_formats(ext_texture_srgb_formats,
                                   ARRAY_SIZE(ext_texture_srgb_formats),
                                   compressed_formats,
                                   num_compressed_formats)
                        && pass;

                /* Remove the sRGB formats from the list since they cannot be
                 * used for the later tests.
                 */
                num_compressed_formats -= 4;
                if (piglit_is_extension_supported("GL_EXT_texture_compression_s3tc")) {
                        num_compressed_formats -= 4;
                }
        }

        piglit_report_result(pass ? PIGLIT_PASS : PIGLIT_FAIL);
}