diff options
| -rw-r--r-- | tests/all.py | 1 | ||||
| -rw-r--r-- | tests/spec/arb_direct_state_access/CMakeLists.gl.txt | 1 | ||||
| -rw-r--r-- | tests/spec/arb_direct_state_access/compressedtexturesubimage.c | 256 |
3 files changed, 258 insertions, 0 deletions
diff --git a/tests/all.py b/tests/all.py index 64e582746..f5c8bc7b3 100644 --- a/tests/all.py +++ b/tests/all.py @@ -4249,6 +4249,7 @@ with profile.group_manager( g(['arb_direct_state_access-flushmappednamedbufferrange'], 'flushmappednamedbufferrange') g(['arb_direct_state_access-getnamedbufferparameter'], 'getnamedbufferparameter') g(['arb_direct_state_access-getnamedbuffersubdata'], 'getnamedbuffersubdata') + g(['arb_direct_state_access-compressedtexturesubimage'], 'compressedtexturesubimage') with profile.group_manager( PiglitGLTest, diff --git a/tests/spec/arb_direct_state_access/CMakeLists.gl.txt b/tests/spec/arb_direct_state_access/CMakeLists.gl.txt index ae79f8838..a9b82ebf9 100644 --- a/tests/spec/arb_direct_state_access/CMakeLists.gl.txt +++ b/tests/spec/arb_direct_state_access/CMakeLists.gl.txt @@ -41,6 +41,7 @@ piglit_add_executable (arb_direct_state_access-gettextureimage-simple gettexture piglit_add_executable (arb_direct_state_access-gettextureimage-targets gettextureimage-targets.c) piglit_add_executable (arb_direct_state_access-compressedtextureimage compressedtextureimage.c) piglit_add_executable (arb_direct_state_access-getcompressedtextureimage getcompressedtextureimage.c) +piglit_add_executable (arb_direct_state_access-compressedtexturesubimage compressedtexturesubimage.c) piglit_add_executable (arb_direct_state_access-texture-storage-multisample texture-storage-multisample.c) piglit_add_executable (arb_direct_state_access-texture-buffer texture-buffer.c) piglit_add_executable (arb_direct_state_access-create-samplers create-samplers.c) diff --git a/tests/spec/arb_direct_state_access/compressedtexturesubimage.c b/tests/spec/arb_direct_state_access/compressedtexturesubimage.c new file mode 100644 index 000000000..716ee7b10 --- /dev/null +++ b/tests/spec/arb_direct_state_access/compressedtexturesubimage.c @@ -0,0 +1,256 @@ +/* + * Copyright 2015 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 compressedtexturesubimage.c + * + * The opposite of getcompressedtextureimage. + * The basic idea is to create some fake compressed data, upload it to the + * driver with DSA, download it with the traditional commands, and compare. + * Of course, this assumes that the traditional commands are correct, which + * may not actually be the case. + */ + +#include "piglit-util-gl.h" + +PIGLIT_GL_TEST_CONFIG_BEGIN + + config.supports_gl_compat_version = 20; + + config.window_visual = PIGLIT_GL_VISUAL_RGBA | + PIGLIT_GL_VISUAL_DOUBLE; + +PIGLIT_GL_TEST_CONFIG_END + +/* Copied from Mesa src/mesa/main/formats.csv: + * MESA_FORMAT_RGBA_DXT5, s3tc, 4, 4, x128 + */ +#define FORMAT GL_COMPRESSED_RGBA_S3TC_DXT5_EXT +#define WIDTH 32 +#define HEIGHT 32 +#define WIDTH_IN_BLOCKS 8 +#define HEIGHT_IN_BLOCKS 8 +#define BLOCK_BYTES 16 +#define IMAGE_SIZE (WIDTH_IN_BLOCKS * HEIGHT_IN_BLOCKS * BLOCK_BYTES) +#define CHAR_LIMIT 100 + +static GLubyte *expected; +static bool global_pass = true; + +static void +subtest(bool local_result, const char *test_name) +{ + global_pass = local_result && global_pass; + piglit_report_subtest_result(local_result ? PIGLIT_PASS : PIGLIT_FAIL, + test_name); +} + +static void +init_random_data(void) +{ + int i; + + expected = malloc(18 * IMAGE_SIZE); + for (i = 0; i < 18 * IMAGE_SIZE; ++i) { + expected[i] = (GLubyte) rand(); + } +} + +void +piglit_init(int argc, char **argv) +{ + piglit_require_extension("GL_ARB_direct_state_access"); + piglit_require_extension("GL_ARB_texture_storage"); + + if (piglit_is_extension_supported("GL_EXT_texture_compression_s3tc")) + piglit_require_extension("GL_EXT_texture_compression_s3tc"); + else + piglit_require_extension("GL_ANGLE_texture_compression_dxt5"); + + srand(0); + init_random_data(); +} + +static bool +compare_to_expected(const GLubyte *data, int num_layers) +{ + return memcmp(expected, data, num_layers * IMAGE_SIZE) == 0; +} + +static void +traditional_download(GLenum target, int num_layers, GLubyte *data) +{ + int i; + + /* Download it using traditional path */ + if (target == GL_TEXTURE_CUBE_MAP) { + for (i = 0; i < num_layers; ++i) { + glGetCompressedTexImage( + GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, 0, + data + i * IMAGE_SIZE); + } + } + else + glGetCompressedTexImage(target, 0, data); +} + +static void +upload_subtest(GLenum target, bool use_pbo) +{ + GLuint tex, pbo_pack, pbo_unpack; + int num_layers; + char test_name [CHAR_LIMIT]; + GLubyte *data = expected; + bool pass = true; + + /* Prepare to read data from expected */ + if (use_pbo) { + glGenBuffers(1, &pbo_unpack); + glBindBuffer(GL_PIXEL_UNPACK_BUFFER, pbo_unpack); + glBufferData(GL_PIXEL_UNPACK_BUFFER, 18 * IMAGE_SIZE, + expected, GL_STATIC_DRAW); + pass = piglit_check_gl_error(GL_NO_ERROR) && pass; + data = NULL; + } + + /* Upload it using DSA */ + glCreateTextures(target, 1, &tex); + + switch (target) { + + case GL_TEXTURE_2D: + num_layers = 1; + glTextureStorage2D(tex, 1, FORMAT, WIDTH, HEIGHT); + glCompressedTextureSubImage2D(tex, 0, 0, 0, WIDTH, HEIGHT, + FORMAT, num_layers * IMAGE_SIZE, + data); + break; + case GL_TEXTURE_2D_ARRAY: + num_layers = 3; + glTextureStorage3D(tex, 1, FORMAT, WIDTH, HEIGHT, num_layers); + glCompressedTextureSubImage3D(tex, 0, 0, 0, 0, WIDTH, HEIGHT, + num_layers, FORMAT, + num_layers * IMAGE_SIZE, data); + break; + case GL_TEXTURE_CUBE_MAP: + num_layers = 6; + glTextureStorage2D(tex, 1, FORMAT, WIDTH, HEIGHT); + glCompressedTextureSubImage3D(tex, 0, 0, 0, 0, WIDTH, HEIGHT, + num_layers, FORMAT, + num_layers * IMAGE_SIZE, data); + break; + case GL_TEXTURE_CUBE_MAP_ARRAY: + num_layers = 18; + glTextureStorage3D(tex, 1, FORMAT, WIDTH, HEIGHT, num_layers); + glCompressedTextureSubImage3D(tex, 0, 0, 0, 0, WIDTH, HEIGHT, + num_layers, FORMAT, + num_layers * IMAGE_SIZE, data); + break; + default: + printf("Bad texture target.\n"); + piglit_report_result(PIGLIT_FAIL); + + } + pass = piglit_check_gl_error(GL_NO_ERROR) && pass; + + /* Download it using traditional method */ + if (use_pbo) { + /* Prepare PBO */ + GLubyte *junk = malloc(18 * IMAGE_SIZE); + memset(junk, 123, 18 * IMAGE_SIZE); + glGenBuffers(1, &pbo_pack); + glBindBuffer(GL_PIXEL_PACK_BUFFER, pbo_pack); + glBufferData(GL_PIXEL_PACK_BUFFER, 18 * IMAGE_SIZE, + junk, GL_STATIC_READ); + free(junk); + pass = piglit_check_gl_error(GL_NO_ERROR) && pass; + + /* Do the transfer */ + glBindTexture(target, tex); + traditional_download(target, num_layers, (void *) 0); + pass = piglit_check_gl_error(GL_NO_ERROR) && pass; + + /* Map the data */ + data = glMapBuffer(GL_PIXEL_PACK_BUFFER, GL_READ_ONLY); + pass = piglit_check_gl_error(GL_NO_ERROR) && pass; + } + else { + data = malloc(18 * IMAGE_SIZE); + glBindTexture(target, tex); + traditional_download(target, num_layers, data); + pass = piglit_check_gl_error(GL_NO_ERROR) && pass; + } + + /* Perform comparison and report the results. */ + snprintf(test_name, CHAR_LIMIT, "upload %s%s", + piglit_get_gl_enum_name(target), use_pbo ? " PBO" : ""); + pass = compare_to_expected(data, num_layers) && pass; + subtest(pass, test_name); + + /* Clean up */ + glDeleteTextures(1, &tex); + if (use_pbo) { + glDeleteBuffers(1, &pbo_unpack); + glDeleteBuffers(1, &pbo_pack); + } + else + free(data); +} + +enum piglit_result +piglit_display(void) +{ + /* According to the EXT_texture_compression_s3tc spec: + * "The S3TC texture compression algorithm supports only 2D + * images without borders. CompressedTexImage1DARB and + * CompressedTexImage3DARB produce an INVALID_ENUM error if + * <internalformat> is an S3TC format." + * + * Array textures can use CompressedTextureSubImage3D, but + * CompressedTextureSubImage1D will still throw an error. This is + * because most compression formats use 2D compression, so 1D + * compressed textures don't make sense. + */ + GLuint tex; + glCreateTextures(GL_TEXTURE_1D, 1, &tex); + glCompressedTextureSubImage1D(tex, 0, 0, WIDTH * HEIGHT, FORMAT, + IMAGE_SIZE, NULL); + subtest(piglit_check_gl_error(GL_INVALID_ENUM), "GL_TEXTURE_1D"); + + /* Non-PBO tests */ + upload_subtest(GL_TEXTURE_2D, false); + if (piglit_is_extension_supported("GL_EXT_texture_array")) + upload_subtest(GL_TEXTURE_2D_ARRAY, false); + upload_subtest(GL_TEXTURE_CUBE_MAP, false); + if (piglit_is_extension_supported("GL_ARB_texture_cube_map_array")) + upload_subtest(GL_TEXTURE_CUBE_MAP_ARRAY, false); + + /* PBO tests */ + upload_subtest(GL_TEXTURE_2D, true); + if (piglit_is_extension_supported("GL_EXT_texture_array")) + upload_subtest(GL_TEXTURE_2D_ARRAY, true); + upload_subtest(GL_TEXTURE_CUBE_MAP, true); + if (piglit_is_extension_supported("GL_ARB_texture_cube_map_array")) + upload_subtest(GL_TEXTURE_CUBE_MAP_ARRAY, true); + + return global_pass ? PIGLIT_PASS : PIGLIT_FAIL; +} |