From: José Fonseca <[email protected]> Based of fbo-blit.
It's not as strict as it could be, because OpenGL's rules are a bit ambigous in respect to clamping to edges, and because Mesa clamps blit with integer precision. --- tests/fbo/CMakeLists.gl.txt | 1 + tests/fbo/fbo-blit-stretch.cpp | 503 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 504 insertions(+) create mode 100644 tests/fbo/fbo-blit-stretch.cpp diff --git a/tests/fbo/CMakeLists.gl.txt b/tests/fbo/CMakeLists.gl.txt index de25b38..c4d0168 100644 --- a/tests/fbo/CMakeLists.gl.txt +++ b/tests/fbo/CMakeLists.gl.txt @@ -32,6 +32,7 @@ piglit_add_executable (fbo-luminance-alpha fbo-luminance-alpha.c) piglit_add_executable (fbo-bind-renderbuffer fbo-bind-renderbuffer.c) piglit_add_executable (fbo-blit fbo-blit.c) piglit_add_executable (fbo-blit-d24s8 fbo-blit-d24s8.c) +piglit_add_executable (fbo-blit-stretch fbo-blit-stretch.cpp) piglit_add_executable (fbo-blending-formats fbo-blending-formats.c) piglit_add_executable (fbo-copypix fbo-copypix.c) piglit_add_executable (fbo-readdrawpix fbo-readdrawpix.c) diff --git a/tests/fbo/fbo-blit-stretch.cpp b/tests/fbo/fbo-blit-stretch.cpp new file mode 100644 index 0000000..249ed93 --- /dev/null +++ b/tests/fbo/fbo-blit-stretch.cpp @@ -0,0 +1,503 @@ +/* + * Copyright (C) 2012 VMware, Inc. + * Copyright (C) 2010 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. + * + * Authors: + * Jose Fonseca + * Eric Anholt <[email protected]> + * Brian Paul + */ + +/** @file fbo-blit-stretch.c + * + * Tests EXT_framebuffer_blit with various combinations of window system and + * FBO objects. Because FBOs are generally stored inverted relative to + * window system frambuffers, this could catch flipping failures in blit paths. + * + * See also fbo-blit.c + */ + +#include <algorithm> + +#include "piglit-util-gl-common.h" + + +/* + * XXX: Checkerboard is not a good test pattern, because OpenGL spec allows the + * implementation to clamp against source rectangle edge, as oposed to clamp + * against the source edges, causing different results along the edge. + */ +#define CHECKERBOARD 0 + +#define DSTW 200 +#define DSTH 150 + +PIGLIT_GL_TEST_MAIN( + DSTW /*window_width*/, + DSTH /*window_height*/, + GLUT_RGBA | GLUT_DOUBLE) + +struct TestCase +{ + GLint srcW, srcH; + GLint srcX0; GLint srcY0; GLint srcX1; GLint srcY1; + GLint dstX0; GLint dstY0; GLint dstX1; GLint dstY1; + GLenum filter; +}; + +static void +describe(const TestCase &test) +{ + GLint dstW = piglit_width; + GLint dstH = piglit_height; + + printf("%ix%i (%i, %i)-(%i, %i) => %ix%i (%i, %i)-(%i, %i)", + test.srcW, test.srcH, + test.srcX0, test.srcY0, test.srcX1, test.srcY1, + dstW, dstH, + test.dstX0, test.dstY0, test.dstX1, test.dstY1); + + GLint srcDX = test.srcX1 - test.srcX0; + GLint srcDY = test.srcY1 - test.srcY0; + GLint dstDX = test.dstX1 - test.dstX0; + GLint dstDY = test.dstY1 - test.dstY0; + + if (srcDX < 0) { + printf(" flip_src_x"); + srcDX = -srcDX; + } + if (srcDY < 0) { + printf(" flip_src_y"); + srcDY = -srcDY; + } + if (dstDX < 0) { + printf(" flip_dst_x"); + dstDX = -dstDX; + } + if (dstDY < 0) { + printf(" flip_dst_y"); + dstDY = -dstDY; + } + + if (dstDX > srcDX) + printf(" stretch_x"); + if (dstDX < srcDX) + printf(" shrink_x"); + + if (dstDY > srcDY) + printf(" stretch_y"); + if (dstDY < srcDY) + printf(" shrink_y"); + + if (test.srcX0 < 0 || test.srcX0 > test.srcW || + test.srcX1 < 0 || test.srcX1 > test.srcW) + printf(" clamp_src_x"); + if (test.srcY0 < 0 || test.srcY0 > test.srcH || + test.srcY1 < 0 || test.srcY1 > test.srcH) + printf(" clamp_src_y"); + + if (test.dstX0 < 0 || test.dstX0 > dstW || + test.dstX1 < 0 || test.dstX1 > dstW) + printf(" clamp_dst_x"); + if (test.dstY0 < 0 || test.dstY0 > dstH || + test.dstY1 < 0 || test.dstY1 > dstH) + printf(" clamp_dst_y"); + + switch (test.filter) { + case GL_NEAREST: + printf(" nearest"); + break; + case GL_LINEAR: + printf(" linear"); + break; + default: + assert(0); + } + + printf("\n"); +} + +static void +filter(const TestCase &test, float coord, GLint &coord0, GLint &coord1, float &weight) +{ + switch (test.filter) { + case GL_NEAREST: + coord0 = roundf(coord); + // ambigious + assert(fabsf(coord0 - coord) != 0.5f); + weight = 0.0f; + break; + case GL_LINEAR: + coord0 = floorf(coord); + weight = coord - (float)coord0; + break; + default: + assert(0); + coord0 = 0; + weight = 0.0f; + } + + assert(weight >= 0.0f); + assert(weight < 1.0f); + + coord1 = coord0 + 1; +} + +static void +clamp(GLint &x, GLint xmin, GLint xmax) +{ + if (x < xmin) { + x = xmin; + } + if (x > xmax) { + x = xmax; + } +} + +static float +lerp(float x0, float x1, float w) +{ + return x0 + (x1 - x0) * w; +} + +static float +lerp2d(float xy00, float xy01, float xy10, float xy11, float wx, float wy) +{ + float y0 = lerp(xy00, xy01, wx); + float y1 = lerp(xy10, xy11, wx); + return lerp(y0, y1, wy); +} + +static float clearColor[4] = { +#if CHECKERBOARD + 0.0, 0.0, 1.0, 1.0 +#else + 0.5, 0.5, 0.5, 0.5 +#endif +}; + +static GLboolean +verify(const TestCase &test, GLuint srcFBO, GLuint dstFBO, GLuint numChannels) +{ + GLint srcX0 = test.srcX0; + GLint srcY0 = test.srcY0; + GLint srcX1 = test.srcX1; + GLint srcY1 = test.srcY1; + GLint dstX0 = test.dstX0; + GLint dstY0 = test.dstY0; + GLint dstX1 = test.dstX1; + GLint dstY1 = test.dstY1; + + if (dstX1 < dstX0) { + std::swap(srcX0, srcX1); + std::swap(dstX0, dstX1); + } + if (dstY1 < dstY0) { + std::swap(srcY0, srcY1); + std::swap(dstY0, dstY1); + } + + GLint srcDX = srcX1 - srcX0; + GLint srcDY = srcY1 - srcY0; + GLint dstDX = dstX1 - dstX0; + GLint dstDY = dstY1 - dstY0; + + GLint dstW = piglit_width; + GLint dstH = piglit_height; + + float *srcPixels = new float[test.srcH * test.srcW * numChannels]; + + glBindFramebuffer(GL_READ_FRAMEBUFFER, srcFBO); + glReadPixels(0, 0, test.srcW, test.srcH, GL_RGB, GL_FLOAT, srcPixels); + + float *expectedDstPixels = new float[dstH * dstW * numChannels]; + + for (GLint dstY = 0; dstY < dstH; ++dstY) { + for (GLint dstX = 0; dstX < dstW; ++dstX) { + float *dstPixel = expectedDstPixels + (dstY * dstW + dstX) * numChannels; + for (GLuint c = 0; c < numChannels; ++c) { + dstPixel[c] = clearColor[c]; + } + } + } + + GLint dstX0clamped = std::max(dstX0, 0); + GLint dstY0clamped = std::max(dstY0, 0); + GLint dstX1clamped = std::min(dstX1, dstW); + GLint dstY1clamped = std::min(dstY1, dstH); + + for (GLint dstY = dstY0clamped; dstY < dstY1clamped; ++dstY) { + float srcY = srcY0 + (dstY - dstY0 + 0.5) * srcDY / dstDY; + if (srcY < 0 || srcY >= test.srcH) { + continue; + } + + srcY -= 0.5f; + + GLint srcPixelY0, srcPixelY1; + float weightY; + filter(test, srcY, srcPixelY0, srcPixelY1, weightY); + clamp(srcPixelY0, 0, test.srcH - 1); + clamp(srcPixelY1, 0, test.srcH - 1); + + for (GLint dstX = dstX0clamped; dstX < dstX1clamped; ++dstX) { + float srcX = srcX0 + (dstX - dstX0 + 0.5) * srcDX / dstDX; + if (srcX < 0 || srcX >= test.srcW) { + continue; + } + + srcX -= 0.5f; + + GLint srcPixelX0, srcPixelX1; + float weightX; + filter(test, srcX, srcPixelX0, srcPixelX1, weightX); + clamp(srcPixelX0, 0, test.srcW - 1); + clamp(srcPixelX1, 0, test.srcW - 1); + + float *srcPixel00 = srcPixels + (srcPixelY0 * test.srcW + srcPixelX0) * numChannels; + float *srcPixel01 = srcPixels + (srcPixelY0 * test.srcW + srcPixelX1) * numChannels; + float *srcPixel10 = srcPixels + (srcPixelY1 * test.srcW + srcPixelX0) * numChannels; + float *srcPixel11 = srcPixels + (srcPixelY1 * test.srcW + srcPixelX1) * numChannels; + + float *dstPixel = expectedDstPixels + + (dstY * dstW + dstX) * numChannels; + + for (GLuint c = 0; c < numChannels; ++c) { + dstPixel[c] = lerp2d(srcPixel00[c], + srcPixel01[c], + srcPixel10[c], + srcPixel11[c], + weightX, weightY); + } + } + } + + delete [] srcPixels; + + float *observedDstPixels = new float[dstH * dstW * numChannels]; + glBindFramebuffer(GL_READ_FRAMEBUFFER, dstFBO); + glReadPixels(0, 0, dstW, dstH, GL_RGB, GL_FLOAT, observedDstPixels); + + GLboolean pass; + pass = piglit_compare_images_color(0, 0, dstW, dstH, numChannels, + piglit_tolerance, + expectedDstPixels, + observedDstPixels); + + delete [] observedDstPixels; + delete [] expectedDstPixels; + + return pass; +} + +static void +blit(const TestCase &test) +{ + glClearColor(clearColor[0], clearColor[1], clearColor[2], clearColor[3]); + glClear(GL_COLOR_BUFFER_BIT); + glBlitFramebuffer(test.srcX0, test.srcY0, test.srcX1, test.srcY1, + test.dstX0, test.dstY0, test.dstX1, test.dstY1, + GL_COLOR_BUFFER_BIT, test.filter); +} + + +static GLboolean +run_test(const TestCase &test) +{ + describe(test); + + GLboolean pass; + + GLuint tex; + GLuint fbo; + GLenum status; + + glGenFramebuffers(1, &fbo); + glBindFramebuffer(GL_FRAMEBUFFER, fbo); + +#if CHECKERBOARD + const float color1[4] = {1.0f, 0.0f, 0.0f, 1.0f}; + const float color2[4] = {0.0f, 1.0f, 0.0f, 1.0f}; + tex = piglit_checkerboard_texture(0, 0, test.srcW, test.srcH, 1, 1, color1, color2); +#else + tex = piglit_rgbw_texture(GL_RGBA, test.srcW, test.srcH, GL_FALSE, GL_TRUE, GL_UNSIGNED_NORMALIZED); +#endif + glBindTexture(GL_TEXTURE_2D, tex); + + glFramebufferTexture2D(GL_FRAMEBUFFER, + GL_COLOR_ATTACHMENT0, + GL_TEXTURE_2D, + tex, + 0); + assert(glGetError() == 0); + + status = glCheckFramebufferStatus(GL_FRAMEBUFFER); + if (status != GL_FRAMEBUFFER_COMPLETE) { + pass = GL_TRUE; + } else { + glViewport(0, 0, piglit_width, piglit_height); + piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); + + glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo); + glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0); + + blit(test); + + pass = verify(test, fbo, 0, 3); + + if (!piglit_automatic) { + piglit_present_results(); + if (!pass) { + //getchar(); + } + } + } + + glDeleteFramebuffers(1, &fbo); + glDeleteTextures(1, &tex); + + return pass; +} + +/* + * Constants to help define several test cases. + */ + +#define SRCW 45 +#define SRCH 79 +#define DX 17 +#define DY 11 +#define SRCXMIN 13 +#define SRCYMIN 33 +#define SRCXMAX (SRCXMIN + DX) +#define SRCYMAX (SRCYMIN + DY) + +#define DSTXMIN 19 +#define DSTYMIN 23 +#define DSTXMAX (DSTXMIN + DX) +#define DSTYMAX (DSTYMIN + DY) + +const TestCase +tests[] = { + { + SRCW, SRCH, + SRCXMIN, SRCYMIN, SRCXMAX, SRCYMAX, + DSTXMIN, DSTYMIN, DSTXMAX, DSTYMAX, + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMAX, SRCYMAX, SRCXMIN, SRCYMIN, // flip xy + DSTXMAX, DSTYMAX, DSTXMIN, DSTYMIN, // flip xy + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMAX, SRCYMIN, SRCXMIN, SRCYMAX, // fliped x + DSTXMIN, DSTYMAX, DSTXMAX, DSTYMIN, // fliped y + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMIN, SRCYMAX, SRCXMAX, SRCYMIN, // fliped y + DSTXMAX, DSTYMIN, DSTXMIN, DSTYMAX, // fliped x + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMIN, SRCYMIN, SRCXMAX, SRCYMAX, + DSTXMIN, DSTYMIN, DSTXMAX + 3*DX, DSTYMAX + 3*DY, // strech x y + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMIN, SRCYMIN, SRCXMAX, SRCYMAX, + DSTXMIN, DSTYMIN, DSTXMAX + 3*DX, DSTYMAX + 3*DY, // strech x y + GL_NEAREST, + }, + /* XXX: Clamping tests are temporarily disabled, because Mesa clamps + * with integer, instead of floats, which ends up affecting the whole, + * which goes against the spec. */ +#if 0 + { + SRCW, SRCH, + SRCXMIN, SRCYMIN, SRCXMAX, SRCYMAX, + -DSTXMIN, -DSTYMIN, DSTXMAX, DSTYMAX, // clamp left bottom + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMIN, SRCYMIN, SRCXMAX, SRCYMAX, + DSTXMIN, DSTYMIN, DSTW + DSTXMIN, DSTH + DSTYMIN, // clamp top right + GL_NEAREST, + }, + { + SRCW, SRCH, + -SRCXMIN, -SRCYMIN, SRCXMAX, SRCYMAX, // clamp left bottom + DSTXMIN, DSTYMIN, DSTXMAX, DSTYMAX, + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMIN, SRCYMIN, SRCW + SRCXMIN, SRCH + SRCYMIN, // clamp top right + DSTXMIN, DSTYMIN, DSTXMAX, DSTYMAX, + GL_NEAREST, + }, + { + SRCW, SRCH, + SRCXMAX, SRCYMIN, SRCXMIN, SRCYMAX, // fliped x + -DSTXMIN, DSTH + DSTYMIN, DSTW + DSTXMIN, -DSTYMIN, // fliped y, clamped x y + GL_NEAREST, + }, +#endif + { + SRCW, SRCH, + 0, 0, SRCW, SRCH, + 0, 0, DSTW, DSTH, + GL_NEAREST, + }, +}; + +enum piglit_result +piglit_display(void) +{ + GLboolean pass = GL_TRUE; + for (unsigned i = 0; i < ARRAY_SIZE(tests); i++) { + TestCase test = tests[i]; + + test.filter = GL_NEAREST; + pass = run_test(test) && pass; + + test.filter = GL_LINEAR; + pass = run_test(test) && pass; + } + return pass ? PIGLIT_PASS : PIGLIT_FAIL; +} + + +void +piglit_init(int argc, char **argv) +{ + piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE); + + piglit_require_extension("GL_ARB_framebuffer_object"); +} -- 1.7.10.4 _______________________________________________ Piglit mailing list [email protected] http://lists.freedesktop.org/mailman/listinfo/piglit
