HI, Thankyou for the review!
Most embarrassingly, I am not too sure what would the proper copyright notice should be for the .c file. It started as a -copy- of the .c file of the .c file for ARB_texture_float ... and then I also copied code directly from Mesa. Should I just -add- Intel and each of the parties listed in srx/mesa/main/imports.c ? -Kevin -----Original Message----- From: Palli, Tapani Sent: Friday, November 28, 2014 9:09 AM To: Rogovin, Kevin; [email protected] Subject: Re: oes_texture_float tests: GL_OES_texture_float, GL_OES_texture_half_float, GL_OES_texture_float_linear and GL_OES_texture_half_float_linear I believe you'll need to add additional copyright line there when submitting, otherwise: Reviewed-by: Tapani Pälli <[email protected]> On 08/01/2014 09:26 AM, Kevin Rogovin wrote: > From: Kevin Rogovin <[email protected]> > > Adds unit tests (based off of ARB_texture_float unit test) for GLES2 > texture float extensions. > > --- > tests/all.py | 18 + > tests/spec/CMakeLists.txt | 1 + > tests/spec/oes_texture_float/CMakeLists.gles2.txt | 6 + > tests/spec/oes_texture_float/CMakeLists.txt | 1 + > tests/spec/oes_texture_float/oes_texture_float.c | 529 > ++++++++++++++++++++++ > 5 files changed, 555 insertions(+) > create mode 100644 tests/spec/oes_texture_float/CMakeLists.gles2.txt > create mode 100644 tests/spec/oes_texture_float/CMakeLists.txt > create mode 100644 tests/spec/oes_texture_float/oes_texture_float.c > > diff --git a/tests/all.py b/tests/all.py index 9d7a861..6b2fc15 100644 > --- a/tests/all.py > +++ b/tests/all.py > @@ -2865,6 +2865,24 @@ add_texwrap_format_tests(arb_texture_float, > 'GL_ARB_texture_float') > add_plain_test(arb_texture_float, 'arb_texture_float-texture-float-formats') > add_msaa_formats_tests(arb_texture_float, 'GL_ARB_texture_float') > > + > +oes_texture_float = {} > +spec['OES_texture_float'] = oes_texture_float > +oes_texture_float['OES_texture_float'] = > +concurrent_test('oes_texture_float') > + > +oes_texture_half_float = {} > +spec['OES_texture_half_float'] = oes_texture_half_float > +oes_texture_half_float['OES_texture_half_float'] = > +concurrent_test('oes_texture_float half') > + > +oes_texture_float_linear = {} > +spec['OES_texture_float_linear'] = oes_texture_float_linear > +oes_texture_float_linear['OES_texture_float_linear'] = > +concurrent_test('oes_texture_float linear') > + > +oes_texture_half_float_linear = {} > +spec['OES_texture_half_float_linear'] = oes_texture_half_float_linear > +oes_texture_half_float_linear['OES_texture_half_float_linear'] = > +concurrent_test('oes_texture_float half linear') > + > + > ext_texture_integer = {} > spec['EXT_texture_integer'] = ext_texture_integer > # unsupported for int yet > diff --git a/tests/spec/CMakeLists.txt b/tests/spec/CMakeLists.txt > index c7001f1..c679e15 100644 > --- a/tests/spec/CMakeLists.txt > +++ b/tests/spec/CMakeLists.txt > @@ -109,3 +109,4 @@ add_subdirectory (ext_image_dma_buf_import) > add_subdirectory (arb_blend_func_extended) > add_subdirectory (ext_unpack_subimage) > add_subdirectory (arb_vertex_array_object) > +add_subdirectory (oes_texture_float) > diff --git a/tests/spec/oes_texture_float/CMakeLists.gles2.txt > b/tests/spec/oes_texture_float/CMakeLists.gles2.txt > new file mode 100644 > index 0000000..4e787e2 > --- /dev/null > +++ b/tests/spec/oes_texture_float/CMakeLists.gles2.txt > @@ -0,0 +1,6 @@ > +include_directories( > + ${GLEXT_INCLUDE_DIR} > + ${OPENGL_INCLUDE_PATH} > +) > +link_libraries(piglitutil_${piglit_target_api}) > +piglit_add_executable(oes_texture_float oes_texture_float.c) > diff --git a/tests/spec/oes_texture_float/CMakeLists.txt > b/tests/spec/oes_texture_float/CMakeLists.txt > new file mode 100644 > index 0000000..144a306 > --- /dev/null > +++ b/tests/spec/oes_texture_float/CMakeLists.txt > @@ -0,0 +1 @@ > +piglit_include_target_api() > diff --git a/tests/spec/oes_texture_float/oes_texture_float.c > b/tests/spec/oes_texture_float/oes_texture_float.c > new file mode 100644 > index 0000000..9564ca7 > --- /dev/null > +++ b/tests/spec/oes_texture_float/oes_texture_float.c > @@ -0,0 +1,529 @@ > +/* > + * Copyright (c) 2011 VMware, Inc. > + * > + * Permission is hereby granted, free of charge, to any person > +obtaining a > + * copy of this software and associated documentation files (the > +"Software"), > + * to deal in the Software without restriction, including without > +limitation > + * 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. > + */ > + > +/** > + * Tests for: > + * GL_OES_texture_float, > + * GL_OES_texture_half_float, > + * GL_OES_texture_float_linear and > + * GL_OES_texture_half_float_linear > + * > + * Usage: oes_texture_float [half] [linear] > + * > + */ > + > + > +#include <stdio.h> > + > +#include "piglit-util-gl.h" > + > +PIGLIT_GL_TEST_CONFIG_BEGIN > + > + config.supports_gl_es_version = 20; > + > + config.window_visual = PIGLIT_GL_VISUAL_RGBA | > +PIGLIT_GL_VISUAL_DOUBLE; > + > +PIGLIT_GL_TEST_CONFIG_END > + > +static GLint TexWidth = 16, TexHeight = 16; static GLint BiasUniform > += -1, ScaleUniform = -1, TexUniform = -1; static const float Scale = > +1.0 / 2000.0, Bias = 0.5; > + > + > + > +struct format_info > +{ > + const char *Name; > + GLenum Format; > + int NumComponents; > +}; > + > +static const struct format_info Formats[] = { > + { "GL_RGBA", GL_RGBA, 4 }, > + { "GL_RGB", GL_RGB, 3 }, > + { "GL_ALPHA", GL_ALPHA, 1 }, > + { "GL_LUMINANCE", GL_LUMINANCE, 1 }, > + { "GL_LUMINANCE_ALPHA", GL_LUMINANCE_ALPHA, 2 }, }; > + > +static const char *VertShaderText = > + "attribute highp vec2 coord01; \n" > + "varying mediump vec2 tex_coord; \n" > + "void main() \n" > + "{ \n" > + " tex_coord = coord01; \n" > + " gl_Position =vec4(coord01*2.0 - vec2(1.0, 1.0), 0.0, 1.0); \n" > + "} \n"; > + > +static const char *FragShaderText = > + "uniform mediump float bias, scale; \n" > + "uniform mediump sampler2D tex; \n" > + "varying mediump vec2 tex_coord; \n" > + "void main() \n" > + "{ \n" > + " mediump vec4 t = vec4(texture2D(tex, tex_coord.xy)); \n" > + " gl_FragColor = t * scale + bias; \n" > + "} \n"; > + > + > +static GLuint Program, AttributeLoc; > + > + > + > +static void > +fill_array_fp32(int comps, int texels, void *buf, const float val[4]) > +{ > + GLfloat *f = (GLfloat*) buf; > + int i, j; > + > + for (i = 0; i < texels; i++) { > + for (j = 0; j < comps; j++) { > + f[i * comps + j] = val[j]; > + } > + } > +} > + > + > +/* Taken from Mesa: src/mesa/main/imports.h */ typedef union { > +GLfloat f; GLint i; GLuint u; } fi_type; static inline int > +IROUND(float f) { > + return (int) ((f >= 0.0F) ? (f + 0.5F) : (f - 0.5F)); } > + > + > +/* Taken from Mesa: src/mesa/main/imports.c */ > +static int > +_mesa_round_to_even(float val) > +{ > + int rounded = IROUND(val); > + > + if (val - floor(val) == 0.5) { > + if (rounded % 2 != 0) > + rounded += val > 0 ? -1 : 1; > + } > + > + return rounded; > +} > + > +static uint16_t > +_mesa_float_to_half(float val) > +{ > + const fi_type fi = {val}; > + const int flt_m = fi.i & 0x7fffff; > + const int flt_e = (fi.i >> 23) & 0xff; > + const int flt_s = (fi.i >> 31) & 0x1; > + int s, e, m = 0; > + uint16_t result; > + > + /* sign bit */ > + s = flt_s; > + > + /* handle special cases */ > + if ((flt_e == 0) && (flt_m == 0)) { > + /* zero */ > + /* m = 0; - already set */ > + e = 0; > + } > + else if ((flt_e == 0) && (flt_m != 0)) { > + /* denorm -- denorm float maps to 0 half */ > + /* m = 0; - already set */ > + e = 0; > + } > + else if ((flt_e == 0xff) && (flt_m == 0)) { > + /* infinity */ > + /* m = 0; - already set */ > + e = 31; > + } > + else if ((flt_e == 0xff) && (flt_m != 0)) { > + /* NaN */ > + m = 1; > + e = 31; > + } > + else { > + /* regular number */ > + const int new_exp = flt_e - 127; > + if (new_exp < -14) { > + /* The float32 lies in the range (0.0, min_normal16) and is rounded > + * to a nearby float16 value. The result will be either zero, > subnormal, > + * or normal. > + */ > + e = 0; > + m = _mesa_round_to_even((1 << 24) * fabsf(fi.f)); > + } > + else if (new_exp > 15) { > + /* map this value to infinity */ > + /* m = 0; - already set */ > + e = 31; > + } > + else { > + /* The float32 lies in the range > + * [min_normal16, max_normal16 + max_step16) > + * and is rounded to a nearby float16 value. The result will be > + * either normal or infinite. > + */ > + e = new_exp + 15; > + m = _mesa_round_to_even(flt_m / (float) (1 << 13)); > + } > + } > + > + assert(0 <= m && m <= 1024); > + if (m == 1024) { > + /* The float32 was rounded upwards into the range of the next exponent, > + * so bump the exponent. This correctly handles the case where f32 > + * should be rounded up to float16 infinity. > + */ > + ++e; > + m = 0; > + } > + > + result = (s << 15) | (e << 10) | m; > + return result; > + > +} > + > +static void > +fill_array_fp16(int comps, int texels, void *buf, const float val[4]) > +{ > + uint16_t *f = (uint16_t*) buf; > + int i, j; > + > + for (i = 0; i < texels; i++) { > + for (j = 0; j < comps; j++) { > + f[i * comps + j] = _mesa_float_to_half(val[j]); > + } > + } > +} > + > + > +struct texture_float_info > +{ > + void (*fill_array)(int comps, int texels, void *buf, const float val[4]); > + GLenum TextureType; > + size_t SizeOfType; > + const char *TestName; > + const char *ExtensionName; > + const char *ExtensionNameLinearFilter; > +}; > + > +const struct texture_float_info Tests[]= > + { > + { > + fill_array_fp32, > + GL_FLOAT, 4, > + "oes-texture-float", > + "GL_OES_texture_float", > + "GL_OES_texture_float_linear" > + }, > + > + { > + fill_array_fp16, > + GL_HALF_FLOAT_OES, 2, > + "oes-texture-half-float", > + "GL_OES_texture_half_float", > + "GL_OES_texture_half_float_linear" > + }, > + }; > + > + > +static GLboolean > +check_error(const char *file, int line, const struct texture_float_info > *test) > +{ > + GLenum err = glGetError(); > + if (err) { > + printf("%s: error 0x%x at %s:%d\n", test->TestName, err, file, line); > + return GL_TRUE; > + } > + return GL_FALSE; > +} > + > + > +/** Scale a float in [-1000, 1000] to [0, 1] */ > +static float > +scale_and_bias(float val) > +{ > + return val * Scale + Bias; > +} > + > + > +/** > + * Get a color to use for filling the texture image. > + * Range of values is [-1000, 1000] > + */ > +static void > +get_texture_color(GLfloat value[4]) > +{ > + static const GLfloat colors[12][4] = { > + { 690.0, 633.0, -649.0, -975.0 }, > + { 409.0, -678.0, 624.0, -976.0 }, > + { -460.0, -102.0, -983.0, 120.0 }, > + { 202.0, 75.0, 826.0, -339.0 }, > + { -709.0, 620.0, 204.0, -666.0 }, > + { 718.0, -299.0, 290.0, 383.0 }, > + { 634.0, 235.0, 571.0, -651.0 }, > + { -984.0, -99.0, 448.0, 263.0 }, > + { -466.0, 356.0, -155.0, 500.0 }, > + { 678.0, -531.0, 81.0, -783.0 }, > + { -76.0, 98.0, -106.0, -875.0 }, > + { 730.0, -723.0, -656.0, -980.0 } > + }; > + static int i = 0; > + value[0] = colors[i][0]; > + value[1] = colors[i][1]; > + value[2] = colors[i][2]; > + value[3] = colors[i][3]; > + i = (i + 1) % 12; > +} > + > + > +/** \return GL_TRUE for pass, GL_FALSE for fail */ > +static GLboolean > +test_format(const struct format_info *info, const struct texture_float_info > *test, GLboolean generate_mipmap) > +{ > + const int comps = info->NumComponents; > + const int texels = TexWidth * TexHeight; > + const int w = piglit_width / 10; > + const int h = piglit_height / 10; > + GLfloat expected[4]; > + void *image; > + float value[4]; > + int p; > + GLushort drawIndices[] = > + { > + 0, 1, 2, > + 0, 2, 3 > + }; > + > + /** printf("Testing %s of %s\n", info->Name, test->TestName); **/ > + > + get_texture_color(value); > + > + /* alloc, fill texture image */ > + image = malloc(comps * texels * test->SizeOfType); > + test->fill_array(comps, texels, image, value); > + > + > + glTexImage2D(GL_TEXTURE_2D, 0, info->Format, TexWidth, TexHeight, 0, > + info->Format, test->TextureType, image); > + if(generate_mipmap) { > + int w, h, l; > + for(w=TexWidth/2, h=TexHeight/2, l=1; w>0 || h>0; w/=2, h/=2, ++l) { > + int useW, useH; > + useW = (w!=0) ? w : 1; > + useH = (h!=0) ? h : 1; > + glTexImage2D(GL_TEXTURE_2D, l, info->Format, useW, useH, 0, > + info->Format, test->TextureType, image); > + } > + } > + > + free(image); > + > + if (check_error(__FILE__, __LINE__, test)) > + return GL_FALSE; > + > + /* compute expected color */ > + switch (info->Format) { > + case GL_RGBA: > + expected[0] = scale_and_bias(value[0]); > + expected[1] = scale_and_bias(value[1]); > + expected[2] = scale_and_bias(value[2]); > + expected[3] = scale_and_bias(value[3]); > + break; > + case GL_RGB: > + expected[0] = scale_and_bias(value[0]); > + expected[1] = scale_and_bias(value[1]); > + expected[2] = scale_and_bias(value[2]); > + expected[3] = scale_and_bias(1.0); > + break; > + case GL_ALPHA: > + expected[0] = > + expected[1] = > + expected[2] = scale_and_bias(0.0); > + expected[3] = scale_and_bias(value[0]); > + break; > + case GL_LUMINANCE: > + expected[0] = > + expected[1] = > + expected[2] = scale_and_bias(value[0]); > + expected[3] = scale_and_bias(1.0); > + break; > + case GL_LUMINANCE_ALPHA: > + expected[0] = > + expected[1] = > + expected[2] = scale_and_bias(value[0]); > + expected[3] = scale_and_bias(value[1]); > + break; > + default: > + abort(); > + } > + > + /* draw */ > + > + > + > + glClearColor(0.5, 0.5, 0.5, 0.0); > + glClear(GL_COLOR_BUFFER_BIT); > + glDisable(GL_DEPTH_TEST); > + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, drawIndices); > + > + /* test */ > + p = piglit_probe_pixel_rgba(w/2, h/2, expected); > + if (!p) { > + int i; > + > + printf(" Failed with format %s:\n", info->Name); > + printf(" Texture color = "); > + for (i = 0; i < comps; i++) { > + printf("%f", value[i]); > + if (i + 1 < comps) > + printf(", "); > + } > + printf("\n"); > + } > + > + piglit_swap_buffers(); > + > + > + return p; > +} > + > +static GLboolean > +test_each_format(const struct texture_float_info *test, GLboolean > generate_mipmap) > +{ > + int f; > + GLboolean pass = GL_TRUE; > + for (f = 0; f < ARRAY_SIZE(Formats); f++) { > + if (!test_format(&Formats[f], test, generate_mipmap)) { > + pass = GL_FALSE; > + } > + } > + return pass; > +} > + > +static const struct texture_float_info *ActiveTest = NULL; > +static GLboolean linearFilter = GL_FALSE; > + > + > +enum piglit_result > +piglit_display(void) > +{ > + GLboolean pass = GL_TRUE; > + GLenum minFilters[] = > + { > + GL_NEAREST, > + GL_LINEAR, > + GL_NEAREST_MIPMAP_NEAREST, > + GL_NEAREST_MIPMAP_LINEAR, > + GL_LINEAR_MIPMAP_NEAREST, > + GL_LINEAR_MIPMAP_LINEAR, > + }; > + GLenum magFilters[] = > + { > + GL_NEAREST, > + GL_LINEAR, > + }; > + > + if (linearFilter) { > + int i, j; > + GLenum magFilter, minFilter; > + > + for (i = 0; i < ARRAY_SIZE(magFilters); ++i) { > + magFilter = magFilters[i]; > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter); > + for (j = 0; j < ARRAY_SIZE(minFilters); ++j) { > + minFilter = minFilters[j]; > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter); > + if (!test_each_format(ActiveTest, minFilter!=GL_NEAREST && > minFilter!=GL_LINEAR)) { > + pass = GL_FALSE; > + } > + } > + } > + } else { > + pass = test_each_format(ActiveTest, GL_FALSE); > + } > + > + return pass ? PIGLIT_PASS : PIGLIT_FAIL; > +} > + > +static GLfloat AttributeValues[] = > + { > + 0.0f, 0.0f, > + 1.0f, 0.0f, > + 1.0f, 1.0f, > + 0.0f, 1.0f, > + }; > + > +void > +piglit_init(int argc, char **argv) > +{ > + GLuint Texture; > + GLboolean half = GL_FALSE; > + int i; > + > + for (i = 1; i<argc; ++i) { > + if (!strcmp(argv[i], "half")) { > + half = GL_TRUE; > + } else if (!strcmp(argv[i], "linear")) { > + linearFilter = GL_TRUE; > + } > + } > + > + if (half) { > + ActiveTest = &Tests[1]; > + } else { > + ActiveTest = &Tests[0]; > + } > + > + if (linearFilter) { > + piglit_require_extension(ActiveTest->ExtensionNameLinearFilter); > + } > + piglit_require_extension(ActiveTest->ExtensionName); > + > + Program = piglit_build_simple_program(VertShaderText, FragShaderText); > + > + glUseProgram(Program); > + > + BiasUniform = glGetUniformLocation(Program, "bias"); > + ScaleUniform = glGetUniformLocation(Program, "scale"); > + TexUniform = glGetUniformLocation(Program, "tex"); > + > + glUniform1f(BiasUniform, Bias); > + glUniform1f(ScaleUniform, Scale); > + glUniform1i(TexUniform, 0); /* tex unit zero */ > + > + AttributeLoc = glGetAttribLocation(Program, "coord01"); > + glEnableVertexAttribArray(AttributeLoc); > + glVertexAttribPointer(AttributeLoc, 2, //slot, count > + GL_FLOAT, GL_FALSE, //type, normalized > + 2*sizeof(float), //stride > + AttributeValues); //pointer/offset > + > + (void) check_error(__FILE__, __LINE__, ActiveTest); > + > + > + glGenTextures(1, &Texture); > + glBindTexture(GL_TEXTURE_2D, Texture); > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); > + glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); > +} _______________________________________________ Piglit mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/piglit
