Google Git
Sign in
fuchsia / third_party / vulkan-cts / a2f2fc5245abcb71b422e9854c06bf94102fc06b / . / external / openglcts / modules / gl / gl4cCopyImageTests.cpp
blob: 23fe62f67092294df04d6601953c09f314c9f5cd [file] [log] [blame]
/*-------------------------------------------------------------------------
* OpenGL Conformance Test Suite
* -----------------------------
*
* Copyright (c) 2015-2016 The Khronos Group Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/ /*!
* \file gl4cCopyImageTests.cpp
* \brief Implements CopyImageSubData functional tests.
*/ /*-------------------------------------------------------------------*/
#include "gl4cCopyImageTests.hpp"
#include "gluDefs.hpp"
#include "gluStrUtil.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuFloat.hpp"
#include "tcuTestLog.hpp"
#include <algorithm>
#include <iomanip>
#include <sstream>
#include "deMath.h"
/* There are far too much combinations specified for FunctionalTest.
*
* Following flags controls what is enabled. Set as 1 to enable
* all test case from given category, 0 otherwise.
*
* By default everything is disabled - which still gives 14560 test cases.
*
* ALL_FORMAT - selects all internal formats, 61 x 61
* ALL_TARGETS - selects all valid targets, 10 x 10
* ALL_IMG_DIM - selects all image dimmensions, 9 x 9
* ALL_REG_DIM - selects all region dimmensions, 7 x 7
* ALL_REG_POS - selects all region positions, like left-top corner, 8 x 8
*/
#define COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_FORMATS 0
#define COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_TARGETS 0
#define COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_IMG_DIM 0
#define COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_DIM 0
#define COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS 0
/* The following flags controls if workarounds are enabled */
#define COPY_IMAGE_WRKARD_FORMATS 0
using namespace glw;
namespace gl4cts
{
namespace CopyImage
{
/** Various utilities used by all tests
*
**/
class Utils
{
public:
/* Routines */
static bool areFormatsCompatible(glw::GLenum src, glw::GLenum dst);
static bool comparePixels(glw::GLenum left_internal_format, const glw::GLdouble& left_red,
const glw::GLdouble& left_green, const glw::GLdouble& left_blue,
const glw::GLdouble& left_alpha, glw::GLenum right_internal_format,
const glw::GLdouble& right_red, const glw::GLdouble& right_green,
const glw::GLdouble& right_blue, const glw::GLdouble& right_alpha);
static bool comparePixels(glw::GLuint left_pixel_size, const glw::GLubyte* left_pixel_data,
glw::GLuint right_pixel_size, const glw::GLubyte* right_pixel_data);
static void deleteTexture(deqp::Context& context, glw::GLenum target, glw::GLuint name);
static bool isTargetMultilayer(glw::GLenum target);
static bool isTargetMultilevel(glw::GLenum target);
static bool isTargetMultisampled(glw::GLenum target);
static glw::GLuint generateTexture(deqp::Context& context, glw::GLenum target);
static void maskPixelForFormat(glw::GLenum internal_format, glw::GLubyte* pixel);
static glw::GLdouble getEpsilon(glw::GLenum internal_format);
static glw::GLuint getPixelSizeForFormat(glw::GLenum internal_format);
static glw::GLenum getFormat(glw::GLenum internal_format);
static glw::GLuint getNumberOfChannels(glw::GLenum internal_format);
static std::string getPixelString(glw::GLenum internal_format, const glw::GLubyte* pixel);
static glw::GLenum getType(glw::GLenum internal_format);
static void makeTextureComplete(deqp::Context& context, glw::GLenum target, glw::GLuint id, glw::GLint base_level,
glw::GLint max_level);
static glw::GLuint prepareCompressedTex(deqp::Context& context, glw::GLenum target, glw::GLenum internal_format);
static glw::GLuint prepareMultisampleTex(deqp::Context& context, glw::GLenum target, glw::GLsizei n_samples);
static glw::GLuint prepareRenderBuffer(deqp::Context& context, glw::GLenum internal_format);
static glw::GLuint prepareTex16x16x6(deqp::Context& context, glw::GLenum target, glw::GLenum internal_format,
glw::GLenum format, glw::GLenum type, glw::GLuint& out_buf_id);
static void prepareTexture(deqp::Context& context, glw::GLuint name, glw::GLenum target,
glw::GLenum internal_format, glw::GLenum format, glw::GLenum type, glw::GLuint level,
glw::GLuint width, glw::GLuint height, glw::GLuint depth, const glw::GLvoid* pixels,
glw::GLuint& out_buf_id);
static glw::GLenum transProxyToRealTarget(glw::GLenum target);
static glw::GLenum transRealToBindTarget(glw::GLenum target);
static void readChannel(glw::GLenum type, glw::GLuint channel, const glw::GLubyte* pixel, glw::GLdouble& out_value);
static void writeChannel(glw::GLenum type, glw::GLuint channel, glw::GLdouble value, glw::GLubyte* pixel);
static void packPixel(glw::GLenum internal_format, glw::GLenum type, glw::GLdouble red, glw::GLdouble green,
glw::GLdouble blue, glw::GLdouble alpha, glw::GLubyte* out_pixel);
static void unpackPixel(glw::GLenum format, glw::GLenum type, const glw::GLubyte* pixel, glw::GLdouble& out_red,
glw::GLdouble& out_green, glw::GLdouble& out_blue, glw::GLdouble& out_alpha);
static bool unpackAndComaprePixels(glw::GLenum left_format, glw::GLenum left_type, glw::GLenum left_internal_format,
const glw::GLubyte* left_pixel, glw::GLenum right_format, glw::GLenum right_type,
glw::GLenum right_internal_format, const glw::GLubyte* right_pixel);
static inline bool roundComponent(glw::GLenum internal_format, glw::GLenum component, glw::GLdouble& value);
};
/* Global constants */
static const GLenum s_internal_formats[] = {
/* R8 */
GL_R8, GL_R8I, GL_R8UI, GL_R8_SNORM,
/* R16 */
GL_R16, GL_R16F, GL_R16I, GL_R16UI, GL_R16_SNORM,
/* R32 */
GL_R32F, GL_R32I, GL_R32UI,
/* RG8 */
GL_RG8, GL_RG8I, GL_RG8UI, GL_RG8_SNORM,
/* RG16 */
GL_RG16, GL_RG16F, GL_RG16I, GL_RG16UI, GL_RG16_SNORM,
/* RG32 */
GL_RG32F, GL_RG32I, GL_RG32UI,
/* RGB8 */
GL_RGB8, GL_RGB8I, GL_RGB8UI, GL_RGB8_SNORM,
/* RGB16 */
GL_RGB16, GL_RGB16F, GL_RGB16I, GL_RGB16UI, GL_RGB16_SNORM,
/* RGB32 */
GL_RGB32F, GL_RGB32I, GL_RGB32UI,
/* RGBA8 */
GL_RGBA8, GL_RGBA8I, GL_RGBA8UI, GL_RGBA8_SNORM,
/* RGBA16 */
GL_RGBA16, GL_RGBA16F, GL_RGBA16I, GL_RGBA16UI, GL_RGBA16_SNORM,
/* RGBA32 */
GL_RGBA32F, GL_RGBA32I, GL_RGBA32UI,
/* 8 */
GL_R3_G3_B2, GL_RGBA2,
/* 12 */
GL_RGB4,
/* 15 */
GL_RGB5,
/* 16 */
GL_RGBA4, GL_RGB5_A1,
/* 30 */
GL_RGB10,
/* 32 */
GL_RGB10_A2, GL_RGB10_A2UI, GL_R11F_G11F_B10F, GL_RGB9_E5,
/* 36 */
GL_RGB12,
/* 48 */
GL_RGBA12,
};
static const GLenum s_invalid_targets[] = {
GL_TEXTURE_BUFFER,
GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
GL_TEXTURE_CUBE_MAP_POSITIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
GL_PROXY_TEXTURE_1D,
GL_PROXY_TEXTURE_1D_ARRAY,
GL_PROXY_TEXTURE_2D,
GL_PROXY_TEXTURE_2D_ARRAY,
GL_PROXY_TEXTURE_2D_MULTISAMPLE,
GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY,
GL_PROXY_TEXTURE_3D,
GL_PROXY_TEXTURE_CUBE_MAP,
GL_PROXY_TEXTURE_CUBE_MAP_ARRAY,
GL_PROXY_TEXTURE_RECTANGLE,
};
static const GLenum s_valid_targets[] = {
GL_RENDERBUFFER,
GL_TEXTURE_1D,
GL_TEXTURE_1D_ARRAY,
GL_TEXTURE_2D,
GL_TEXTURE_2D_ARRAY,
GL_TEXTURE_2D_MULTISAMPLE,
GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
GL_TEXTURE_3D,
GL_TEXTURE_CUBE_MAP,
GL_TEXTURE_CUBE_MAP_ARRAY,
GL_TEXTURE_RECTANGLE,
};
static const GLuint s_n_internal_formats = sizeof(s_internal_formats) / sizeof(s_internal_formats[0]);
static const GLuint s_n_invalid_targets = sizeof(s_invalid_targets) / sizeof(s_invalid_targets[0]);
static const GLuint s_n_valid_targets = sizeof(s_valid_targets) / sizeof(s_valid_targets[0]);
/**
* Pixel compatibility depends on pixel size. However value returned by getPixelSizeForFormat
* needs some refinements
*
* @param internal_format Internal format of image
*
* @return Size of pixel for compatibility checks
**/
GLuint getPixelSizeForCompatibilityVerification(GLenum internal_format)
{
GLuint size = Utils::getPixelSizeForFormat(internal_format);
switch (internal_format)
{
case GL_RGBA2:
size = 1;
break;
default:
break;
}
return size;
}
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_FORMATS == 0
/** Filters out formats that should not be tested by FunctionalTest
*
* @param format Internal format
*
* @return true if format should be tested, false otherwise
**/
bool filterFormats(GLenum format)
{
bool result = true;
switch (format)
{
/* R8 */
case GL_R8I:
case GL_R8UI:
case GL_R8_SNORM:
/* R16 */
case GL_R16:
case GL_R16F:
case GL_R16I:
case GL_R16UI:
case GL_R16_SNORM:
/* R32 */
case GL_R32F:
case GL_R32I:
case GL_R32UI:
/* RG8 */
case GL_RG8:
case GL_RG8I:
case GL_RG8UI:
case GL_RG8_SNORM:
/* RG16 */
case GL_RG16:
case GL_RG16F:
case GL_RG16I:
case GL_RG16UI:
case GL_RG16_SNORM:
/* RG32 */
case GL_RG32F:
case GL_RG32I:
case GL_RG32UI:
/* RGB8 */
case GL_RGB8:
case GL_RGB8I:
case GL_RGB8UI:
case GL_RGB8_SNORM:
/* RGB16 */
case GL_RGB16:
case GL_RGB16F:
case GL_RGB16I:
case GL_RGB16UI:
case GL_RGB16_SNORM:
/* RGB32 */
case GL_RGB32I:
case GL_RGB32UI:
/* RGBA8 */
case GL_RGBA8:
case GL_RGBA8I:
case GL_RGBA8UI:
case GL_RGBA8_SNORM:
/* RGBA16 */
case GL_RGBA16:
case GL_RGBA16F:
case GL_RGBA16I:
case GL_RGBA16UI:
case GL_RGBA16_SNORM:
/* RGBA32 */
case GL_RGBA32F:
case GL_RGBA32I:
case GL_RGBA32UI:
result = false;
break;
default:
result = true;
break;
}
return result;
}
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_FORMATS */
/** Checks if two internal_formats are compatible
*
* @param src Internal format of source image
* @param dst Internal format of destination image
*
* @return true for compatible formats, false otherwise
**/
bool Utils::areFormatsCompatible(glw::GLenum src, glw::GLenum dst)
{
const GLuint dst_size = getPixelSizeForCompatibilityVerification(dst);
const GLuint src_size = getPixelSizeForCompatibilityVerification(src);
if (dst_size != src_size)
{
return false;
}
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_FORMATS == 0
if ((false == filterFormats(src)) || (false == filterFormats(dst)))
{
return false;
}
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_FORMATS */
if (src != dst)
{
if ((GL_R3_G3_B2 == dst) || (GL_R3_G3_B2 == src) || (GL_RGBA2 == dst) || (GL_RGBA2 == src) ||
(GL_RGBA4 == dst) || (GL_RGBA4 == src) || (GL_RGB5_A1 == dst) || (GL_RGB5_A1 == src) || (GL_RGB10 == dst) ||
(GL_RGB10 == src))
{
return false;
}
}
#if COPY_IMAGE_WRKARD_FORMATS
if ((GL_RGB10_A2 == src) && (GL_R11F_G11F_B10F == dst) || (GL_RGB10_A2 == src) && (GL_RGB9_E5 == dst) ||
(GL_RGB10_A2UI == src) && (GL_R11F_G11F_B10F == dst) || (GL_RGB10_A2UI == src) && (GL_RGB9_E5 == dst) ||
(GL_RGB9_E5 == src) && (GL_RGB10_A2 == dst) || (GL_RGB9_E5 == src) && (GL_RGB10_A2UI == dst) ||
(GL_R11F_G11F_B10F == src) && (GL_RGB10_A2 == dst) || (GL_R11F_G11F_B10F == src) && (GL_RGB10_A2UI == dst))
{
return false;
}
#endif /* COPY_IMAGE_WRKARD_FORMATS */
if (2 == dst_size)
{
if (src == dst)
{
return true;
}
if (((GL_RGB4 == src) && (GL_RGB4 != dst)) || ((GL_RGB4 != src) && (GL_RGB4 == dst)) ||
((GL_RGB5 == src) && (GL_RGB5 != dst)) || ((GL_RGB5 != src) && (GL_RGB5 == dst)))
{
return false;
}
return true;
}
if (4 == dst_size)
{
if (src == dst)
{
return true;
}
return true;
}
return true;
}
/** Compare two pixels
*
* @param left_internal_format Internal format of left image
* @param left_red Red channel of left image
* @param left_green Green channel of left image
* @param left_blue Blue channel of left image
* @param left_alpha Alpha channel of left image
* @param right_internal_format Internal format of right image
* @param right_red Red channel of right image
* @param right_green Green channel of right image
* @param right_blue Blue channel of right image
* @param right_alpha Alpha channel of right image
*
* @return true if pixels match, false otherwise
**/
bool Utils::comparePixels(GLenum left_internal_format, const GLdouble& left_red, const GLdouble& left_green,
const GLdouble& left_blue, const GLdouble& left_alpha, GLenum right_internal_format,
const GLdouble& right_red, const GLdouble& right_green, const GLdouble& right_blue,
const GLdouble& right_alpha)
{
const GLuint left_n_channels = getNumberOfChannels(left_internal_format);
const GLuint right_n_channels = getNumberOfChannels(right_internal_format);
const GLuint n_channels = (left_n_channels >= right_n_channels) ? right_n_channels : left_n_channels;
const GLdouble left_channels[4] = { left_red, left_green, left_blue, left_alpha };
const GLdouble right_channels[4] = { right_red, right_green, right_blue, right_alpha };
for (GLuint i = 0; i < n_channels; ++i)
{
const GLdouble left = left_channels[i];
const GLdouble right = right_channels[i];
const GLdouble left_eps = getEpsilon(left_internal_format);
const GLdouble right_eps = getEpsilon(right_internal_format);
const GLdouble eps = fabs(std::max(left_eps, right_eps));
if (eps < fabs(left - right))
{
return false;
}
}
return true;
}
/** Compare two pixels with memcmp
*
* @param left_pixel_size Size of left pixel
* @param left_pixel_data Data of left pixel
* @param right_pixel_size Size of right pixel
* @param right_pixel_data Data of right pixel
*
* @return true if memory match, false otherwise
**/
bool Utils::comparePixels(GLuint left_pixel_size, const GLubyte* left_pixel_data, GLuint right_pixel_size,
const GLubyte* right_pixel_data)
{
const GLuint pixel_size = (left_pixel_size >= right_pixel_size) ? left_pixel_size : right_pixel_size;
return 0 == memcmp(left_pixel_data, right_pixel_data, pixel_size);
}
/** Delete texture or renderbuffer
*
* @param context Test context
* @param target Image target
* @param name Name of image
**/
void Utils::deleteTexture(deqp::Context& context, GLenum target, GLuint name)
{
const Functions& gl = context.getRenderContext().getFunctions();
if (GL_RENDERBUFFER == target)
{
gl.deleteRenderbuffers(1, &name);
}
else
{
gl.deleteTextures(1, &name);
}
}
/** Get epsilon for given internal_format
*
* @param internal_format Internal format of image
*
* @return Epsilon value
**/
GLdouble Utils::getEpsilon(GLenum internal_format)
{
GLdouble epsilon;
switch (internal_format)
{
case GL_R8:
case GL_R8_SNORM:
case GL_R16:
case GL_R16F:
case GL_R16_SNORM:
case GL_R32F:
case GL_R8I:
case GL_R8UI:
case GL_R16I:
case GL_R16UI:
case GL_R32I:
case GL_R32UI:
case GL_RG8:
case GL_RG8_SNORM:
case GL_RG16:
case GL_RG16F:
case GL_RG16_SNORM:
case GL_RG32F:
case GL_RG8I:
case GL_RG8UI:
case GL_RG16I:
case GL_RG16UI:
case GL_RG32I:
case GL_RG32UI:
case GL_R3_G3_B2:
case GL_RGB4:
case GL_RGB5:
case GL_RGB8:
case GL_RGB8_SNORM:
case GL_R11F_G11F_B10F:
case GL_RGB16:
case GL_RGB16F:
case GL_RGB16_SNORM:
case GL_RGB32F:
case GL_RGB8I:
case GL_RGB8UI:
case GL_RGB10:
case GL_RGB16I:
case GL_RGB16UI:
case GL_RGB32I:
case GL_RGB32UI:
case GL_RGB9_E5:
case GL_RGBA2:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGBA8:
case GL_RGBA8_SNORM:
case GL_RGB10_A2:
case GL_RGBA16:
case GL_RGBA16F:
case GL_RGBA16_SNORM:
case GL_RGBA32F:
case GL_RGBA8I:
case GL_RGBA8UI:
case GL_RGB10_A2UI:
case GL_RGBA16I:
case GL_RGBA16UI:
case GL_RGBA32I:
case GL_RGBA32UI:
epsilon = 0.0;
break;
case GL_RGB12:
case GL_RGBA12:
epsilon = 0.00390625;
break;
default:
TCU_FAIL("Invalid enum");
break;
}
return epsilon;
}
/** Get format for given internal format
*
* @param internal_format Internal format
*
* @return Format
**/
GLenum Utils::getFormat(GLenum internal_format)
{
GLenum format = 0;
switch (internal_format)
{
/* R */
case GL_R8:
case GL_R8_SNORM:
case GL_R16:
case GL_R16F:
case GL_R16_SNORM:
case GL_R32F:
format = GL_RED;
break;
case GL_R8I:
case GL_R8UI:
case GL_R16I:
case GL_R16UI:
case GL_R32I:
case GL_R32UI:
format = GL_RED_INTEGER;
break;
/* RG */
case GL_RG8:
case GL_RG8_SNORM:
case GL_RG16:
case GL_RG16F:
case GL_RG16_SNORM:
case GL_RG32F:
format = GL_RG;
break;
case GL_RG8I:
case GL_RG8UI:
case GL_RG16I:
case GL_RG16UI:
case GL_RG32I:
case GL_RG32UI:
format = GL_RG_INTEGER;
break;
/* RGB */
case GL_R3_G3_B2:
case GL_RGB4:
case GL_RGB5:
case GL_RGB8:
case GL_RGB8_SNORM:
case GL_R11F_G11F_B10F:
case GL_RGB12:
case GL_RGB16:
case GL_RGB16F:
case GL_RGB16_SNORM:
case GL_RGB32F:
case GL_RGB9_E5:
format = GL_RGB;
break;
case GL_RGB8I:
case GL_RGB8UI:
case GL_RGB16I:
case GL_RGB16UI:
case GL_RGB32I:
case GL_RGB32UI:
format = GL_RGB_INTEGER;
break;
/* RGBA */
case GL_RGB10:
case GL_RGBA2:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGBA8:
case GL_RGBA8_SNORM:
case GL_RGB10_A2:
case GL_RGBA12:
case GL_RGBA16:
case GL_RGBA16F:
case GL_RGBA16_SNORM:
case GL_RGBA32F:
format = GL_RGBA;
break;
case GL_RGBA8I:
case GL_RGBA8UI:
case GL_RGB10_A2UI:
case GL_RGBA16I:
case GL_RGBA16UI:
case GL_RGBA32I:
case GL_RGBA32UI:
format = GL_RGBA_INTEGER;
break;
default:
TCU_FAIL("Invalid enum");
break;
}
return format;
}
/** Get number of channels for given internal_format
*
* @param internal_format Internal format
*
* @return Number of channels
**/
GLuint Utils::getNumberOfChannels(GLenum internal_format)
{
GLuint result = 0;
switch (internal_format)
{
case GL_R8:
case GL_R8_SNORM:
case GL_R16:
case GL_R16F:
case GL_R16_SNORM:
case GL_R32F:
case GL_R8I:
case GL_R8UI:
case GL_R16I:
case GL_R16UI:
case GL_R32I:
case GL_R32UI:
result = 1;
break;
case GL_RG8:
case GL_RG8_SNORM:
case GL_RG16:
case GL_RG16F:
case GL_RG16_SNORM:
case GL_RG32F:
case GL_RG8I:
case GL_RG8UI:
case GL_RG16I:
case GL_RG16UI:
case GL_RG32I:
case GL_RG32UI:
result = 2;
break;
case GL_R3_G3_B2:
case GL_RGB4:
case GL_RGB5:
case GL_RGB8:
case GL_RGB8_SNORM:
case GL_RGB10:
case GL_R11F_G11F_B10F:
case GL_RGB12:
case GL_RGB16:
case GL_RGB16F:
case GL_RGB16_SNORM:
case GL_RGB32F:
case GL_RGB9_E5:
case GL_RGB8I:
case GL_RGB8UI:
case GL_RGB16I:
case GL_RGB16UI:
case GL_RGB32I:
case GL_RGB32UI:
result = 3;
break;
case GL_RGBA2:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGBA8:
case GL_RGBA8_SNORM:
case GL_RGB10_A2:
case GL_RGBA12:
case GL_RGBA16:
case GL_RGBA16F:
case GL_RGBA16_SNORM:
case GL_RGBA32F:
case GL_RGBA8I:
case GL_RGBA8UI:
case GL_RGB10_A2UI:
case GL_RGBA16I:
case GL_RGBA16UI:
case GL_RGBA32I:
case GL_RGBA32UI:
result = 4;
break;
default:
TCU_FAIL("Invalid enum");
break;
}
return result;
}
/** Get type for given internal format
*
* @param internal_format Internal format
*
* @return Type
**/
GLenum Utils::getType(GLenum internal_format)
{
GLenum type = 0;
switch (internal_format)
{
case GL_R8:
case GL_R8UI:
case GL_RG8:
case GL_RG8UI:
case GL_RGB8:
case GL_RGB8UI:
case GL_RGBA8:
case GL_RGBA8UI:
type = GL_UNSIGNED_BYTE;
break;
case GL_R8_SNORM:
case GL_R8I:
case GL_RG8_SNORM:
case GL_RG8I:
case GL_RGB8_SNORM:
case GL_RGB8I:
case GL_RGBA8_SNORM:
case GL_RGBA8I:
type = GL_BYTE;
break;
case GL_R3_G3_B2:
type = GL_UNSIGNED_BYTE_3_3_2;
break;
case GL_RGB4:
case GL_RGB5:
type = GL_UNSIGNED_SHORT_5_6_5;
break;
case GL_RGBA2:
case GL_RGBA4:
type = GL_UNSIGNED_SHORT_4_4_4_4;
break;
case GL_RGB5_A1:
type = GL_UNSIGNED_SHORT_5_5_5_1;
break;
case GL_RGB10:
case GL_RGB10_A2:
case GL_RGB10_A2UI:
type = GL_UNSIGNED_INT_2_10_10_10_REV;
break;
case GL_R16F:
case GL_RG16F:
case GL_RGB16F:
case GL_RGBA16F:
type = GL_HALF_FLOAT;
break;
case GL_R16:
case GL_R16UI:
case GL_RG16:
case GL_RG16UI:
case GL_RGB12:
case GL_RGB16:
case GL_RGB16UI:
case GL_RGBA12:
case GL_RGBA16:
case GL_RGBA16UI:
type = GL_UNSIGNED_SHORT;
break;
case GL_R16_SNORM:
case GL_R16I:
case GL_RG16_SNORM:
case GL_RG16I:
case GL_RGB16_SNORM:
case GL_RGB16I:
case GL_RGBA16_SNORM:
case GL_RGBA16I:
type = GL_SHORT;
break;
case GL_R32UI:
case GL_RG32UI:
case GL_RGB32UI:
case GL_RGBA32UI:
type = GL_UNSIGNED_INT;
break;
case GL_RGB9_E5:
type = GL_UNSIGNED_INT_5_9_9_9_REV;
break;
case GL_R32I:
case GL_RG32I:
case GL_RGB32I:
case GL_RGBA32I:
type = GL_INT;
break;
case GL_R32F:
case GL_RG32F:
case GL_RGB32F:
case GL_RGBA32F:
type = GL_FLOAT;
break;
case GL_R11F_G11F_B10F:
type = GL_UNSIGNED_INT_10F_11F_11F_REV;
break;
default:
TCU_FAIL("Invalid enum");
break;
}
return type;
}
/** Returns mask that should be applied to pixel value
*
* @param internal_format Internal format of texture
* @param pixel Pixel data
*
* @return Mask
**/
void Utils::maskPixelForFormat(GLenum internal_format, GLubyte* pixel)
{
switch (internal_format)
{
case GL_RGB10:
/* UINT_10_10_10_2 - ALPHA will be set to 3*/
pixel[0] |= 0x03;
break;
default:
break;
}
}
/** Get size of pixel for given internal format
*
* @param internal_format Internal format
*
* @return Number of bytes used by given format
**/
GLuint Utils::getPixelSizeForFormat(GLenum internal_format)
{
GLuint size = 0;
switch (internal_format)
{
/* 8 */
case GL_R8:
case GL_R8I:
case GL_R8UI:
case GL_R8_SNORM:
case GL_R3_G3_B2:
size = 1;
break;
/* 8 */
case GL_RGBA2:
size = 2;
break;
/* 12 */
case GL_RGB4:
size = 2;
break;
/* 15 */
case GL_RGB5:
size = 2;
break;
/* 16 */
case GL_RG8:
case GL_RG8I:
case GL_RG8UI:
case GL_RG8_SNORM:
case GL_R16:
case GL_R16F:
case GL_R16I:
case GL_R16UI:
case GL_R16_SNORM:
case GL_RGBA4:
case GL_RGB5_A1:
size = 2;
break;
/* 24 */
case GL_RGB8:
case GL_RGB8I:
case GL_RGB8UI:
case GL_RGB8_SNORM:
size = 3;
break;
/* 30 */
case GL_RGB10:
size = 4;
break;
/* 32 */
case GL_RGBA8:
case GL_RGBA8I:
case GL_RGBA8UI:
case GL_RGBA8_SNORM:
case GL_RG16:
case GL_RG16F:
case GL_RG16I:
case GL_RG16UI:
case GL_RG16_SNORM:
case GL_R32F:
case GL_R32I:
case GL_R32UI:
case GL_RGB10_A2:
case GL_RGB10_A2UI:
case GL_R11F_G11F_B10F:
case GL_RGB9_E5:
size = 4;
break;
/* 36 */
case GL_RGB12:
size = 6;
break;
/* 48 */
case GL_RGB16:
case GL_RGB16F:
case GL_RGB16I:
case GL_RGB16UI:
case GL_RGB16_SNORM:
size = 6;
break;
/* 64 */
case GL_RGBA12:
case GL_RGBA16:
case GL_RGBA16F:
case GL_RGBA16I:
case GL_RGBA16UI:
case GL_RGBA16_SNORM:
case GL_RG32F:
case GL_RG32I:
case GL_RG32UI:
size = 8;
break;
/* 96 */
case GL_RGB32F:
case GL_RGB32I:
case GL_RGB32UI:
size = 12;
break;
/* 128 */
case GL_RGBA32F:
case GL_RGBA32I:
case GL_RGBA32UI:
size = 16;
break;
default:
TCU_FAIL("Invalid enum");
break;
}
return size;
}
/** Prepare string that represents bytes of pixel
*
* @param internal_format Format
* @param pixel Pixel data
*
* @return String
**/
std::string Utils::getPixelString(GLenum internal_format, const GLubyte* pixel)
{
const GLuint pixel_size = Utils::getPixelSizeForFormat(internal_format);
std::stringstream stream;
stream << "0x";
for (GLint i = pixel_size - 1; i >= 0; --i)
{
stream << std::setbase(16) << std::setw(2) << std::setfill('0') << (GLuint)pixel[i];
}
return stream.str();
}
/** Check if target supports multiple layers
*
* @param target Texture target
*
* @return true if target is multilayered
**/
bool Utils::isTargetMultilayer(GLenum target)
{
bool result = false;
switch (target)
{
case GL_TEXTURE_1D_ARRAY:
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
case GL_TEXTURE_3D:
case GL_TEXTURE_CUBE_MAP_ARRAY:
result = true;
break;
default:
break;
}
return result;
}
/** Check if target supports multiple level
*
* @param target Texture target
*
* @return true if target supports mipmaps
**/
bool Utils::isTargetMultilevel(GLenum target)
{
bool result = true;
switch (target)
{
case GL_TEXTURE_2D_MULTISAMPLE:
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
case GL_TEXTURE_RECTANGLE:
case GL_RENDERBUFFER:
result = false;
break;
default:
break;
}
return result;
}
/** Check if target is multisampled
*
* @param target Texture target
*
* @return true when for multisampled formats, false otherwise
**/
bool Utils::isTargetMultisampled(GLenum target)
{
bool result = false;
switch (target)
{
case GL_TEXTURE_2D_MULTISAMPLE:
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
result = true;
break;
default:
break;
}
return result;
}
/** Generate texture object
*
* @param context Test context
* @param target Target of texture
*
* @return Generated name
**/
glw::GLuint Utils::generateTexture(deqp::Context& context, GLenum target)
{
const Functions& gl = context.getRenderContext().getFunctions();
GLuint name = 0;
switch (target)
{
case GL_RENDERBUFFER:
gl.genRenderbuffers(1, &name);
GLU_EXPECT_NO_ERROR(gl.getError(), "GenRenderbuffers");
break;
default:
gl.genTextures(1, &name);
GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures");
break;
}
return name;
}
/** Sets base and max level parameters of texture to make it complete
*
* @param context Test context
* @param target GLenum representing target of texture that should be created
* @param id Id of texture
* @param base_level Base level value, eg 0
* @param max_level Max level value, eg 0
**/
void Utils::makeTextureComplete(deqp::Context& context, GLenum target, GLuint id, GLint base_level, GLint max_level)
{
const Functions& gl = context.getRenderContext().getFunctions();
if (GL_RENDERBUFFER == target)
{
return;
}
/* Translate proxies into real targets */
target = transRealToBindTarget(transProxyToRealTarget(target));
gl.bindTexture(target, id);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
/* Set levels */
if (GL_TEXTURE_BUFFER != target)
{
gl.texParameteri(target, GL_TEXTURE_BASE_LEVEL, base_level);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
gl.texParameteri(target, GL_TEXTURE_MAX_LEVEL, max_level);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
/* Integer textures won't be complete with the default min filter
* of GL_NEAREST_MIPMAP_LINEAR (or GL_LINEAR for rectangle textures)
* and default mag filter of GL_LINEAR, so switch to nearest.
*/
if (GL_TEXTURE_2D_MULTISAMPLE != target && GL_TEXTURE_2D_MULTISAMPLE_ARRAY != target)
{
gl.texParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if (GL_TEXTURE_RECTANGLE != target)
{
gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
}
else
{
gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
}
}
}
/* Clean binding point */
gl.bindTexture(target, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
}
/** Generate and initialize texture for given target
*
* @param context Test context
* @param target GLenum representing target of texture that should be created
* @param n_samples Number of samples
*
* @return "name" of texture
**/
GLuint Utils::prepareMultisampleTex(deqp::Context& context, GLenum target, GLsizei n_samples)
{
static const GLuint depth = 6;
const Functions& gl = context.getRenderContext().getFunctions();
static const GLuint height = 16;
static const GLenum internal_format = GL_RGBA8;
GLuint name = 0;
static const GLuint width = 16;
gl.genTextures(1, &name);
GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures");
/* Initialize */
switch (target)
{
case GL_TEXTURE_2D_MULTISAMPLE:
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage2DMultisample(target, n_samples, internal_format, width, height, GL_FALSE /* fixedsamplelocation */);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexImage2DMultisample");
break;
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage3DMultisample(target, n_samples, internal_format, width, height, depth,
GL_FALSE /* fixedsamplelocation */);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexImage3DMultisample");
break;
default:
TCU_FAIL("Invalid enum");
break;
}
/* Clean binding point */
gl.bindTexture(target, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
return name;
}
/** Generate and initialize texture for given target
*
* @param context Test context
* @param internal_format Internal format of render buffer
*
* @return "name" of texture
**/
GLuint Utils::prepareRenderBuffer(deqp::Context& context, GLenum internal_format)
{
const Functions& gl = context.getRenderContext().getFunctions();
static const GLuint height = 16;
GLuint name = 0;
static const GLuint width = 16;
gl.genRenderbuffers(1, &name);
GLU_EXPECT_NO_ERROR(gl.getError(), "GenRenderbuffers");
/* Initialize */
gl.bindRenderbuffer(GL_RENDERBUFFER, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindRenderbuffer");
gl.renderbufferStorage(GL_RENDERBUFFER, internal_format, width, height);
GLU_EXPECT_NO_ERROR(gl.getError(), "RenderbufferStorage");
/* Clean binding point */
gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindRenderbuffer");
return name;
}
/** Generate and initialize texture for given target
*
* @param context Test context
* @param target GLenum representing target of texture that should be created
* @param internal_format <internalformat>
* @param format <format>
* @param type <type>
* @param out_buf_id ID of buffer that will be used for TEXTURE_BUFFER
*
* @return "name" of texture
**/
GLuint Utils::prepareTex16x16x6(deqp::Context& context, GLenum target, GLenum internal_format, GLenum format,
GLenum type, GLuint& out_buf_id)
{
static const GLuint depth = 6;
static const GLuint height = 16;
static const GLuint level = 0;
GLuint name = 0;
static const GLchar* pixels = 0;
static const GLuint width = 16;
name = generateTexture(context, target);
prepareTexture(context, name, target, internal_format, format, type, level, width, height, depth, pixels,
out_buf_id);
return name;
}
/** Initialize texture
*
* @param context Test context
* @param name Name of texture object
* @param target GLenum representing target of texture that should be created
* @param internal_format <internalformat>
* @param format <format>
* @param type <type>
* @param level <level>
* @param width <width>
* @param height <height>
* @param depth <depth>
* @param pixels <pixels>
* @param out_buf_id ID of buffer that will be used for TEXTURE_BUFFER
*
* @return "name" of texture
**/
void Utils::prepareTexture(deqp::Context& context, GLuint name, GLenum target, GLenum internal_format, GLenum format,
GLenum type, GLuint level, GLuint width, GLuint height, GLuint depth, const GLvoid* pixels,
GLuint& out_buf_id)
{
static const GLint border = 0;
GLenum error = 0;
const GLchar* function_name = "unknown";
const Functions& gl = context.getRenderContext().getFunctions();
static const GLsizei samples = 1;
/* Translate proxies into real targets */
target = transProxyToRealTarget(target);
/* Initialize */
switch (target)
{
case GL_RENDERBUFFER:
gl.bindRenderbuffer(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindRenderbuffer");
gl.renderbufferStorage(target, internal_format, width, height);
GLU_EXPECT_NO_ERROR(gl.getError(), "RenderbufferStorage");
gl.bindRenderbuffer(target, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindRenderbuffer");
break;
case GL_TEXTURE_1D:
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage1D(target, level, internal_format, width, border, format, type, pixels);
error = gl.getError();
function_name = "TexImage1D";
break;
case GL_TEXTURE_1D_ARRAY:
case GL_TEXTURE_2D:
case GL_TEXTURE_RECTANGLE:
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage2D(target, level, internal_format, width, height, border, format, type, pixels);
error = gl.getError();
function_name = "TexImage2D";
break;
case GL_TEXTURE_2D_MULTISAMPLE:
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage2DMultisample(target, samples, internal_format, width, height, GL_FALSE /* fixedsamplelocation */);
error = gl.getError();
function_name = "TexImage2DMultisample";
break;
case GL_TEXTURE_2D_MULTISAMPLE_ARRAY:
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage3DMultisample(target, samples, internal_format, width, height, depth,
GL_FALSE /* fixedsamplelocation */);
error = gl.getError();
function_name = "TexImage3DMultisample";
break;
case GL_TEXTURE_2D_ARRAY:
case GL_TEXTURE_3D:
case GL_TEXTURE_CUBE_MAP_ARRAY:
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage3D(target, level, internal_format, width, height, depth, border, format, type, pixels);
error = gl.getError();
function_name = "TexImage3D";
break;
case GL_TEXTURE_BUFFER:
gl.genBuffers(1, &out_buf_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers");
gl.bindBuffer(GL_TEXTURE_BUFFER, out_buf_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");
{
GLsizei size = 16;
const GLvoid* data = 0;
if (0 != pixels)
{
size = width;
data = pixels;
}
gl.bufferData(GL_TEXTURE_BUFFER, size, data, GL_DYNAMIC_COPY);
GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData");
}
gl.bindTexture(GL_TEXTURE_BUFFER, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texBuffer(GL_TEXTURE_BUFFER, internal_format, out_buf_id);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexBuffer");
break;
case GL_TEXTURE_CUBE_MAP:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
/* Change target to CUBE_MAP, it will be used later to change base and max level */
target = GL_TEXTURE_CUBE_MAP;
gl.bindTexture(target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, level, internal_format, width, height, border, format, type,
pixels);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, level, internal_format, width, height, border, format, type,
pixels);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, level, internal_format, width, height, border, format, type,
pixels);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X, level, internal_format, width, height, border, format, type,
pixels);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, level, internal_format, width, height, border, format, type,
pixels);
gl.texImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, level, internal_format, width, height, border, format, type,
pixels);
error = gl.getError();
function_name = "TexImage2D";
break;
default:
TCU_FAIL("Invalid enum");
break;
}
if (GL_NO_ERROR != error)
{
context.getTestContext().getLog()
<< tcu::TestLog::Message << "Error: " << glu::getErrorStr(error) << ". Function: " << function_name
<< ". Target: " << glu::getTextureTargetStr(target)
<< ". Format: " << glu::getInternalFormatParameterStr(internal_format) << ", "
<< glu::getTextureFormatName(format) << ", " << glu::getTypeStr(type) << tcu::TestLog::EndMessage;
TCU_FAIL("Failed to create texture");
}
if (GL_RENDERBUFFER != target)
{
/* Clean binding point */
gl.bindTexture(target, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
}
}
/** Translate proxies into real targets
*
* @param target Target to be converted
*
* @return Converted target for proxies, <target> otherwise
**/
GLenum Utils::transProxyToRealTarget(GLenum target)
{
switch (target)
{
case GL_PROXY_TEXTURE_1D:
target = GL_TEXTURE_1D;
break;
case GL_PROXY_TEXTURE_1D_ARRAY:
target = GL_TEXTURE_1D_ARRAY;
break;
case GL_PROXY_TEXTURE_2D:
target = GL_TEXTURE_2D;
break;
case GL_PROXY_TEXTURE_2D_ARRAY:
target = GL_TEXTURE_2D_ARRAY;
break;
case GL_PROXY_TEXTURE_2D_MULTISAMPLE:
target = GL_TEXTURE_2D_MULTISAMPLE;
break;
case GL_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY:
target = GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
break;
case GL_PROXY_TEXTURE_3D:
target = GL_TEXTURE_3D;
break;
case GL_PROXY_TEXTURE_CUBE_MAP:
target = GL_TEXTURE_CUBE_MAP;
break;
case GL_PROXY_TEXTURE_CUBE_MAP_ARRAY:
target = GL_TEXTURE_CUBE_MAP_ARRAY;
break;
case GL_PROXY_TEXTURE_RECTANGLE:
target = GL_TEXTURE_RECTANGLE;
break;
default:
break;
}
return target;
}
/** Translate real targets into binding targets
*
* @param target Target to be converted
*
* @return Converted target for cube map faces, <target> otherwise
**/
GLenum Utils::transRealToBindTarget(GLenum target)
{
switch (target)
{
case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
target = GL_TEXTURE_CUBE_MAP;
break;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
target = GL_TEXTURE_CUBE_MAP;
break;
case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z:
target = GL_TEXTURE_CUBE_MAP;
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
target = GL_TEXTURE_CUBE_MAP;
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
target = GL_TEXTURE_CUBE_MAP;
break;
case GL_TEXTURE_CUBE_MAP_POSITIVE_Z:
target = GL_TEXTURE_CUBE_MAP;
break;
default:
break;
}
return target;
}
/** Read value of channel
*
* @tparam T Type used to store channel value
*
* @param channel Channel index
* @param pixel Pixel data
* @param out_value Read value
**/
template <typename T>
void readBaseTypeFromUnsignedChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
{
static const T max = -1;
const GLdouble d_max = (GLdouble)max;
const T* ptr = (T*)pixel;
const T t_value = ptr[channel];
const GLdouble d_value = (GLdouble)t_value;
out_value = d_value / d_max;
}
/** Read value of channel
*
* @tparam T Type used to store channel value
*
* @param channel Channel index
* @param pixel Pixel data
* @param out_value Read value
**/
template <typename T>
void readBaseTypeFromSignedChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
{
static const GLuint n_bytes = sizeof(T);
static const GLuint n_bits = 8u * n_bytes;
static const T max = (T)((1u << (n_bits - 1u)) - 1u);
const GLdouble d_max = (GLdouble)max;
const T* ptr = (T*)pixel;
const T t_value = ptr[channel];
const GLdouble d_value = (GLdouble)t_value;
out_value = d_value / d_max;
}
/** Read value of channel
*
* @tparam T Type used to store channel value
*
* @param channel Channel index
* @param pixel Pixel data
* @param out_value Read value
**/
void readBaseTypeFromFloatChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
{
const GLfloat* ptr = (const GLfloat*)pixel;
const GLfloat t_value = ptr[channel];
const GLdouble d_value = (GLdouble)t_value;
out_value = d_value;
}
/** Read value of channel
*
* @tparam T Type used to store channel value
*
* @param channel Channel index
* @param pixel Pixel data
* @param out_value Read value
**/
void readBaseTypeFromHalfFloatChannel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
{
const deUint16* ptr = (const deUint16*)pixel;
const deUint16 bits = ptr[channel];
tcu::Float16 val(bits);
const GLdouble d_value = val.asDouble();
out_value = d_value;
}
/** Read value of channel
*
* @tparam T Type used to store pixel
* @tparam size_1 Size of channel in bits
* @tparam size_2 Size of channel in bits
* @tparam size_3 Size of channel in bits
* @tparam off_1 Offset of channel in bits
* @tparam off_2 Offset of channel in bits
* @tparam off_3 Offset of channel in bits
*
* @param channel Channel index
* @param pixel Pixel data
* @param out_value Read value
**/
template <typename T, unsigned int size_1, unsigned int size_2, unsigned int size_3, unsigned int off_1,
unsigned int off_2, unsigned int off_3>
void read3Channel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
{
T mask = 0;
T max = 0;
T off = 0;
const T* ptr = (T*)pixel;
T result = 0;
const T t_value = ptr[0];
static const T max_1 = (1 << size_1) - 1;
static const T max_2 = (1 << size_2) - 1;
static const T max_3 = (1 << size_3) - 1;
switch (channel)
{
case 0:
mask = max_1;
max = max_1;
off = off_1;
break;
case 1:
mask = max_2;
max = max_2;
off = off_2;
break;
case 2:
mask = max_3;
max = max_3;
off = off_3;
break;
default:
TCU_FAIL("Invalid channel");
break;
}
result = (T)((t_value >> off) & mask);
const GLdouble d_max = (GLdouble)max;
const GLdouble d_value = (GLdouble)result;
out_value = d_value / d_max;
}
/** Read value of channel
*
* @tparam T Type used to store pixel
* @tparam size_1 Size of channel in bits
* @tparam size_2 Size of channel in bits
* @tparam size_3 Size of channel in bits
* @tparam size_4 Size of channel in bits
* @tparam off_1 Offset of channel in bits
* @tparam off_2 Offset of channel in bits
* @tparam off_3 Offset of channel in bits
* @tparam off_4 Offset of channel in bits
*
* @param channel Channel index
* @param pixel Pixel data
* @param out_value Read value
**/
template <typename T, unsigned int size_1, unsigned int size_2, unsigned int size_3, unsigned int size_4,
unsigned int off_1, unsigned int off_2, unsigned int off_3, unsigned int off_4>
void read4Channel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
{
T mask = 0;
T max = 0;
T off = 0;
const T* ptr = (T*)pixel;
T result = 0;
const T t_value = ptr[0];
static const T max_1 = (1 << size_1) - 1;
static const T max_2 = (1 << size_2) - 1;
static const T max_3 = (1 << size_3) - 1;
static const T max_4 = (1 << size_4) - 1;
switch (channel)
{
case 0:
mask = max_1;
max = max_1;
off = off_1;
break;
case 1:
mask = max_2;
max = max_2;
off = off_2;
break;
case 2:
mask = max_3;
max = max_3;
off = off_3;
break;
case 3:
mask = max_4;
max = max_4;
off = off_4;
break;
default:
TCU_FAIL("Invalid channel");
break;
}
result = (T)((t_value >> off) & mask);
const GLdouble d_max = (GLdouble)max;
const GLdouble d_value = (GLdouble)result;
out_value = d_value / d_max;
}
/** Read value of channel
*
* @param channel Channel index
* @param pixel Pixel data
* @param out_value Read value
**/
void read11F_11F_10F_Channel(GLuint channel, const GLubyte* pixel, GLdouble& out_value)
{
const deUint32* ptr = (deUint32*)pixel;
deUint32 val = *ptr;
switch (channel)
{
case 0:
{
deUint32 bits = (val & 0x000007ff);
tcu::Float<deUint32, 5, 6, 15, tcu::FLOAT_SUPPORT_DENORM> temp_val(bits);
out_value = temp_val.asDouble();
}
break;
case 1:
{
deUint32 bits = ((val >> 11) & 0x000007ff);
tcu::Float<deUint32, 5, 6, 15, tcu::FLOAT_SUPPORT_DENORM> temp_val(bits);
out_value = temp_val.asDouble();
}
break;
case 2:
{
deUint32 bits = ((val >> 22) & 0x000003ff);
tcu::Float<deUint32, 5, 5, 15, tcu::FLOAT_SUPPORT_DENORM> temp_val(bits);
out_value = temp_val.asDouble();
}
break;
default:
TCU_FAIL("Invalid channel");
break;
}
}
/** Write value of channel
*
* @tparam T Type used to store pixel
*
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
template <typename T>
void writeBaseTypeToUnsignedChannel(GLuint channel, GLdouble value, GLubyte* pixel)
{
static const T max = -1;
const GLdouble d_max = (GLdouble)max;
const GLdouble d_value = value * d_max;
const T t_value = (T)d_value;
T* ptr = (T*)pixel;
ptr[channel] = t_value;
}
/** Write value of channel
*
* @tparam T Type used to store pixel
*
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
template <typename T>
void writeBaseTypeToSignedChannel(GLuint channel, GLdouble value, GLubyte* pixel)
{
static const GLuint n_bytes = sizeof(T);
static const GLuint n_bits = 8u * n_bytes;
static const T max = (T)((1u << (n_bits - 1u)) - 1u);
const GLdouble d_max = (GLdouble)max;
const GLdouble d_value = value * d_max;
const T t_value = (T)d_value;
T* ptr = (T*)pixel;
ptr[channel] = t_value;
}
/** Write value of channel
*
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
void writeBaseTypeToFloatChannel(GLuint channel, GLdouble value, GLubyte* pixel)
{
const GLfloat t_value = (GLfloat)value;
GLfloat* ptr = (GLfloat*)pixel;
ptr[channel] = t_value;
}
/** Write value of channel
*
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
void writeBaseTypeToHalfFloatChannel(GLuint channel, GLdouble value, GLubyte* pixel)
{
deUint16* ptr = (deUint16*)pixel;
tcu::Float16 val(value);
ptr[channel] = val.bits();
}
/** Write value of channel
*
* @tparam T Type used to store pixel
* @tparam size_1 Size of channel in bits
* @tparam size_2 Size of channel in bits
* @tparam size_3 Size of channel in bits
* @tparam off_1 Offset of channel in bits
* @tparam off_2 Offset of channel in bits
* @tparam off_3 Offset of channel in bits
*
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
template <typename T, unsigned int size_1, unsigned int size_2, unsigned int size_3, unsigned int off_1,
unsigned int off_2, unsigned int off_3>
void write3Channel(GLuint channel, GLdouble value, GLubyte* pixel)
{
T mask = 0;
T max = 0;
T off = 0;
T* ptr = (T*)pixel;
T result = 0;
static const T max_1 = (1 << size_1) - 1;
static const T max_2 = (1 << size_2) - 1;
static const T max_3 = (1 << size_3) - 1;
switch (channel)
{
case 0:
mask = max_1;
max = max_1;
off = off_1;
break;
case 1:
mask = max_2;
max = max_2;
off = off_2;
break;
case 2:
mask = max_3;
max = max_3;
off = off_3;
break;
default:
TCU_FAIL("Invalid channel");
break;
}
const GLdouble d_max = (GLdouble)max;
const GLdouble d_value = value * d_max;
const T t_value = (T)d_value;
result = (T)((t_value & mask) << off);
*ptr |= result;
}
/** Write value of channel
*
* @tparam T Type used to store pixel
* @tparam size_1 Size of channel in bits
* @tparam size_2 Size of channel in bits
* @tparam size_3 Size of channel in bits
* @tparam size_4 Size of channel in bits
* @tparam off_1 Offset of channel in bits
* @tparam off_2 Offset of channel in bits
* @tparam off_3 Offset of channel in bits
* @tparam off_4 Offset of channel in bits
*
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
template <typename T, unsigned int size_1, unsigned int size_2, unsigned int size_3, unsigned int size_4,
unsigned int off_1, unsigned int off_2, unsigned int off_3, unsigned int off_4>
void write4Channel(GLuint channel, GLdouble value, GLubyte* pixel)
{
T mask = 0;
T max = 0;
T off = 0;
T* ptr = (T*)pixel;
T result = 0;
static const T max_1 = (1 << size_1) - 1;
static const T max_2 = (1 << size_2) - 1;
static const T max_3 = (1 << size_3) - 1;
static const T max_4 = (1 << size_4) - 1;
switch (channel)
{
case 0:
mask = max_1;
max = max_1;
off = off_1;
break;
case 1:
mask = max_2;
max = max_2;
off = off_2;
break;
case 2:
mask = max_3;
max = max_3;
off = off_3;
break;
case 3:
mask = max_4;
max = max_4;
off = off_4;
break;
default:
TCU_FAIL("Invalid channel");
break;
}
const GLdouble d_max = (GLdouble)max;
const GLdouble d_value = value * d_max;
const T t_value = (T)d_value;
result = (T)((t_value & mask) << off);
*ptr |= result;
}
/** Write value of channel
*
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
void write11F_11F_10F_Channel(GLuint channel, GLdouble value, GLubyte* pixel)
{
deUint32* ptr = (deUint32*)pixel;
switch (channel)
{
case 0:
{
tcu::Float<deUint32, 5, 6, 15, tcu::FLOAT_SUPPORT_DENORM> val(value);
deUint32 bits = val.bits();
*ptr |= bits;
}
break;
case 1:
{
tcu::Float<deUint32, 5, 6, 15, tcu::FLOAT_SUPPORT_DENORM> val(value);
deUint32 bits = val.bits();
*ptr |= (bits << 11);
}
break;
case 2:
{
tcu::Float<deUint32, 5, 5, 15, tcu::FLOAT_SUPPORT_DENORM> val(value);
deUint32 bits = val.bits();
*ptr |= (bits << 22);
}
break;
default:
TCU_FAIL("Invalid channel");
break;
}
}
/** Read value of channel
*
* @param type Type used by pixel
* @param channel Channel index
* @param pixel Pixel data
* @param value Read value
**/
void Utils::readChannel(GLenum type, GLuint channel, const GLubyte* pixel, GLdouble& value)
{
switch (type)
{
/* Base types */
case GL_UNSIGNED_BYTE:
readBaseTypeFromUnsignedChannel<GLubyte>(channel, pixel, value);
break;
case GL_UNSIGNED_SHORT:
readBaseTypeFromUnsignedChannel<GLushort>(channel, pixel, value);
break;
case GL_UNSIGNED_INT:
readBaseTypeFromUnsignedChannel<GLuint>(channel, pixel, value);
break;
case GL_BYTE:
readBaseTypeFromSignedChannel<GLbyte>(channel, pixel, value);
break;
case GL_SHORT:
readBaseTypeFromSignedChannel<GLshort>(channel, pixel, value);
break;
case GL_INT:
readBaseTypeFromSignedChannel<GLint>(channel, pixel, value);
break;
case GL_HALF_FLOAT:
readBaseTypeFromHalfFloatChannel(channel, pixel, value);
break;
case GL_FLOAT:
readBaseTypeFromFloatChannel(channel, pixel, value);
break;
/* Complicated */
/* 3 channles */
case GL_UNSIGNED_BYTE_3_3_2:
read3Channel<GLubyte, 3, 3, 2, 5, 2, 0>(channel, pixel, value);
break;
case GL_UNSIGNED_SHORT_5_6_5:
read3Channel<GLushort, 5, 6, 5, 11, 5, 0>(channel, pixel, value);
break;
/* 4 channels */
case GL_UNSIGNED_SHORT_4_4_4_4:
read4Channel<GLushort, 4, 4, 4, 4, 12, 8, 4, 0>(channel, pixel, value);
break;
case GL_UNSIGNED_SHORT_5_5_5_1:
read4Channel<GLushort, 5, 5, 5, 1, 11, 6, 1, 0>(channel, pixel, value);
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
read4Channel<GLuint, 2, 10, 10, 10, 30, 20, 10, 0>(3 - channel, pixel, value);
break;
case GL_UNSIGNED_INT_5_9_9_9_REV:
read4Channel<GLuint, 5, 9, 9, 9, 27, 18, 9, 0>(3 - channel, pixel, value);
break;
/* R11F_G11F_B10F - uber complicated */
case GL_UNSIGNED_INT_10F_11F_11F_REV:
read11F_11F_10F_Channel(channel, pixel, value);
break;
default:
TCU_FAIL("Invalid enum");
break;
}
}
/** Write value of channel
*
* @param type Type used by pixel
* @param channel Channel index
* @param value Value to write
* @param pixel Pixel data
**/
void Utils::writeChannel(GLenum type, GLuint channel, GLdouble value, GLubyte* pixel)
{
switch (type)
{
/* Base types */
case GL_UNSIGNED_BYTE:
writeBaseTypeToUnsignedChannel<GLubyte>(channel, value, pixel);
break;
case GL_UNSIGNED_SHORT:
writeBaseTypeToUnsignedChannel<GLushort>(channel, value, pixel);
break;
case GL_UNSIGNED_INT:
writeBaseTypeToUnsignedChannel<GLuint>(channel, value, pixel);
break;
case GL_BYTE:
writeBaseTypeToSignedChannel<GLbyte>(channel, value, pixel);
break;
case GL_SHORT:
writeBaseTypeToSignedChannel<GLshort>(channel, value, pixel);
break;
case GL_INT:
writeBaseTypeToSignedChannel<GLint>(channel, value, pixel);
break;
case GL_HALF_FLOAT:
writeBaseTypeToHalfFloatChannel(channel, value, pixel);
break;
case GL_FLOAT:
writeBaseTypeToFloatChannel(channel, value, pixel);
break;
/* Complicated */
/* 3 channles */
case GL_UNSIGNED_BYTE_3_3_2:
write3Channel<GLubyte, 3, 3, 2, 5, 2, 0>(channel, value, pixel);
break;
case GL_UNSIGNED_SHORT_5_6_5:
write3Channel<GLushort, 5, 6, 5, 11, 5, 0>(channel, value, pixel);
break;
/* 4 channels */
case GL_UNSIGNED_SHORT_4_4_4_4:
write4Channel<GLushort, 4, 4, 4, 4, 12, 8, 4, 0>(channel, value, pixel);
break;
case GL_UNSIGNED_SHORT_5_5_5_1:
write4Channel<GLushort, 5, 5, 5, 1, 11, 6, 1, 0>(channel, value, pixel);
break;
case GL_UNSIGNED_INT_2_10_10_10_REV:
write4Channel<GLuint, 2, 10, 10, 10, 30, 20, 10, 0>(3 - channel, value, pixel);
break;
case GL_UNSIGNED_INT_5_9_9_9_REV:
write4Channel<GLuint, 5, 9, 9, 9, 27, 18, 9, 0>(3 - channel, value, pixel);
break;
/* R11F_G11F_B10F - uber complicated */
case GL_UNSIGNED_INT_10F_11F_11F_REV:
write11F_11F_10F_Channel(channel, value, pixel);
break;
default:
TCU_FAIL("Invalid enum");
break;
}
}
/** Packs given channels to pixel
*
* @param internal_format Internal format of image
* @param type Type used by image
* @param red Red channel
* @param green Green channel
* @param blue Blue channel
* @param alpha Alpha channel
* @param out_pixel Pixel data
**/
void Utils::packPixel(GLenum internal_format, GLenum type, GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha,
GLubyte* out_pixel)
{
switch (internal_format)
{
case GL_R8:
case GL_R8_SNORM:
case GL_R16:
case GL_R16F:
case GL_R16_SNORM:
case GL_R32F:
case GL_R8I:
case GL_R8UI:
case GL_R16I:
case GL_R16UI:
case GL_R32I:
case GL_R32UI:
writeChannel(type, 0, red, out_pixel);
break;
case GL_RG8:
case GL_RG8_SNORM:
case GL_RG16:
case GL_RG16F:
case GL_RG16_SNORM:
case GL_RG32F:
case GL_RG8I:
case GL_RG8UI:
case GL_RG16I:
case GL_RG16UI:
case GL_RG32I:
case GL_RG32UI:
writeChannel(type, 0, red, out_pixel);
writeChannel(type, 1, green, out_pixel);
break;
case GL_R3_G3_B2:
case GL_RGB4:
case GL_RGB5:
case GL_RGB8:
case GL_RGB8_SNORM:
case GL_RGB10:
case GL_R11F_G11F_B10F:
case GL_RGB12:
case GL_RGB16:
case GL_RGB16F:
case GL_RGB16_SNORM:
case GL_RGB32F:
case GL_RGB8I:
case GL_RGB8UI:
case GL_RGB16I:
case GL_RGB16UI:
case GL_RGB32I:
case GL_RGB32UI:
writeChannel(type, 0, red, out_pixel);
writeChannel(type, 1, green, out_pixel);
writeChannel(type, 2, blue, out_pixel);
break;
case GL_RGB9_E5:
case GL_RGBA2:
case GL_RGBA4:
case GL_RGB5_A1:
case GL_RGBA8:
case GL_RGBA8_SNORM:
case GL_RGB10_A2:
case GL_RGBA12:
case GL_RGBA16:
case GL_RGBA16F:
case GL_RGBA16_SNORM:
case GL_RGBA32F:
case GL_RGBA8I:
case GL_RGBA8UI:
case GL_RGB10_A2UI:
case GL_RGBA16I:
case GL_RGBA16UI:
case GL_RGBA32I:
case GL_RGBA32UI:
writeChannel(type, 0, red, out_pixel);
writeChannel(type, 1, green, out_pixel);
writeChannel(type, 2, blue, out_pixel);
writeChannel(type, 3, alpha, out_pixel);
break;
default:
TCU_FAIL("Invalid enum");
break;
}
}
/** Unpacks channels from pixel
*
* @param internal_format Internal format of image
* @param type Type used by image
* @param pixel Pixel data
* @param red Red channel
* @param green Green channel
* @param blue Blue channel
* @param alpha Alpha channel
**/
void Utils::unpackPixel(GLenum format, GLenum type, const GLubyte* pixel, GLdouble& out_red, GLdouble& out_green,
GLdouble& out_blue, GLdouble& out_alpha)
{
switch (format)
{
case GL_RED:
case GL_RED_INTEGER:
readChannel(type, 0, pixel, out_red);
out_green = 1.0;
out_blue = 1.0;
out_alpha = 1.0;
break;
case GL_RG:
case GL_RG_INTEGER:
readChannel(type, 0, pixel, out_red);
readChannel(type, 1, pixel, out_green);
out_blue = 1.0;
out_alpha = 1.0;
break;
case GL_RGB:
case GL_RGB_INTEGER:
switch (type)
{
case GL_UNSIGNED_INT_5_9_9_9_REV:
readChannel(type, 0, pixel, out_red);
readChannel(type, 1, pixel, out_green);
readChannel(type, 2, pixel, out_blue);
readChannel(type, 3, pixel, out_alpha);
break;
default:
readChannel(type, 0, pixel, out_red);
readChannel(type, 1, pixel, out_green);
readChannel(type, 2, pixel, out_blue);
out_alpha = 1.0;
break;
}
break;
case GL_RGBA:
case GL_RGBA_INTEGER:
readChannel(type, 0, pixel, out_red);
readChannel(type, 1, pixel, out_green);
readChannel(type, 2, pixel, out_blue);
readChannel(type, 3, pixel, out_alpha);
break;
default:
TCU_FAIL("Invalid enum");
break;
}
}
inline bool Utils::roundComponent(GLenum internal_format, GLenum component, GLdouble& value)
{
int exponent = (internal_format == GL_RGB4 ? 4 : (internal_format == GL_RGB5 ? 5 : 0));
if (!exponent)
return false; //Currently this only happens with GL_RGB4 and GL_RGB5 when stored as 565 type.
int rounded_value = static_cast<int>(floor((pow(2, exponent) - 1) * value + 0.5));
int multiplier = (component == GL_GREEN ? 2 : 1);
if (internal_format == GL_RGB4)
{
multiplier *= 2;
}
value = rounded_value * multiplier;
return true;
}
/** Unpacks pixels and compars them
*
* @param left_format Format of left image
* @param left_type Type of left image
* @param left_internal_format Internal format of left image
* @param left_pixel Data of left pixel
* @param right_format Format of right image
* @param right_type Type of right image
* @param right_internal_format Internal format of right image
* @param right_pixel Data of right pixel
*
* @return true if pixels match, false otherwise
**/
bool Utils::unpackAndComaprePixels(GLenum left_format, GLenum left_type, GLenum left_internal_format,
const GLubyte* left_pixel, GLenum right_format, GLenum right_type,
GLenum right_internal_format, const GLubyte* right_pixel)
{
GLdouble left_red;
GLdouble left_green;
GLdouble left_blue;
GLdouble left_alpha;
GLdouble right_red;
GLdouble right_green;
GLdouble right_blue;
GLdouble right_alpha;
unpackPixel(left_format, left_type, left_pixel, left_red, left_green, left_blue, left_alpha);
unpackPixel(right_format, right_type, right_pixel, right_red, right_green, right_blue, right_alpha);
roundComponent(left_internal_format, GL_RED, left_red);
roundComponent(left_internal_format, GL_GREEN, left_green);
roundComponent(left_internal_format, GL_BLUE, left_blue);
roundComponent(right_internal_format, GL_RED, right_red);
roundComponent(right_internal_format, GL_GREEN, right_green);
roundComponent(right_internal_format, GL_BLUE, right_blue);
return comparePixels(left_internal_format, left_red, left_green, left_blue, left_alpha, right_internal_format,
right_red, right_green, right_blue, right_alpha);
}
/* FunctionalTest */
#define FUNCTIONAL_TEST_N_LAYERS 12
#define FUNCTIONAL_TEST_N_LEVELS 3
/** Constructor
*
* @param context Text context
**/
FunctionalTest::FunctionalTest(deqp::Context& context)
: TestCase(context, "functional", "Test verifies CopyImageSubData copy data as requested")
, m_dst_buf_name(0)
, m_dst_tex_name(0)
, m_rb_name(0)
, m_src_buf_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
for (GLuint src_tgt_id = 0; src_tgt_id < s_n_valid_targets; ++src_tgt_id)
{
const GLenum src_target = s_valid_targets[src_tgt_id];
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_TARGETS == 0
if ((GL_TEXTURE_1D == src_target) || (GL_TEXTURE_1D_ARRAY == src_target) || (GL_TEXTURE_2D == src_target) ||
(GL_TEXTURE_CUBE_MAP == src_target) || (GL_TEXTURE_CUBE_MAP_ARRAY == src_target))
{
continue;
}
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_TARGETS == 0 */
for (GLuint dst_tgt_id = 0; dst_tgt_id < s_n_valid_targets; ++dst_tgt_id)
{
const GLenum dst_target = s_valid_targets[dst_tgt_id];
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_TARGETS == 0
if ((GL_TEXTURE_1D == dst_target) || (GL_TEXTURE_1D_ARRAY == dst_target) || (GL_TEXTURE_2D == dst_target) ||
(GL_TEXTURE_CUBE_MAP == dst_target) || (GL_TEXTURE_CUBE_MAP_ARRAY == dst_target))
{
continue;
}
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_TARGETS == 0 */
/* Skip render buffer as destination */
if (GL_RENDERBUFFER == dst_target)
{
continue;
}
/* Skip multisampled */
if ((true == Utils::isTargetMultisampled(src_target)) || (true == Utils::isTargetMultisampled(dst_target)))
{
continue;
}
for (GLuint src_frmt_id = 0; src_frmt_id < s_n_internal_formats; ++src_frmt_id)
{
const GLenum src_format = s_internal_formats[src_frmt_id];
if (src_format == GL_RGB9_E5 && src_target == GL_RENDERBUFFER)
{
continue;
}
for (GLuint dst_frmt_id = 0; dst_frmt_id < s_n_internal_formats; ++dst_frmt_id)
{
const GLenum dst_format = s_internal_formats[dst_frmt_id];
/* Skip not compatible formats */
if (false == Utils::areFormatsCompatible(src_format, dst_format))
{
continue;
}
prepareTestCases(dst_format, dst_target, src_format, src_target);
}
}
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult FunctionalTest::iterate()
{
GLubyte* dst_pixels[FUNCTIONAL_TEST_N_LEVELS] = { 0 };
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
GLubyte* src_pixels[FUNCTIONAL_TEST_N_LEVELS] = { 0 };
const testCase& test_case = m_test_cases[m_test_case_index];
gl.pixelStorei(GL_PACK_ALIGNMENT, 1);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "PixelStorei");
try
{
/* Prepare pixels */
prepareDstPxls(test_case.m_dst, dst_pixels);
prepareSrcPxls(test_case.m_src, test_case.m_dst.m_internal_format, src_pixels);
/* Prepare textures */
m_dst_tex_name = prepareTexture(test_case.m_dst, (const GLubyte**)dst_pixels, m_dst_buf_name);
if (GL_RENDERBUFFER == test_case.m_src.m_target)
{
targetDesc desc = test_case.m_src;
desc.m_target = GL_TEXTURE_2D;
m_rb_name = prepareTexture(test_case.m_src, (const GLubyte**)src_pixels, m_src_buf_name);
m_src_tex_name = prepareTexture(desc, (const GLubyte**)src_pixels, m_src_buf_name);
}
else
{
m_src_tex_name = prepareTexture(test_case.m_src, (const GLubyte**)src_pixels, m_src_buf_name);
}
/* Copy images and verify results */
result = copyAndVerify(test_case, (const GLubyte**)dst_pixels, (const GLubyte**)src_pixels);
}
catch (tcu::Exception& exc)
{
clean();
cleanPixels((GLubyte**)dst_pixels);
cleanPixels((GLubyte**)src_pixels);
throw exc;
}
/* Free resources */
clean();
cleanPixels((GLubyte**)dst_pixels);
cleanPixels((GLubyte**)src_pixels);
/* Set result */
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failure. " << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Calculate dimmensions of all levels based on size of specific level
*
* @param target Target of image
* @param level Level index
* @param width Width of image at <level>
* @param height Height of image at <level>
* @param out_widths Calcualted widths, array of FUNCTIONAL_TEST_N_LEVELS'th elements
* @param out_heights Calculated heights, array of FUNCTIONAL_TEST_N_LEVELS'th elements
* @param out_depths Calculated dephts, array of FUNCTIONAL_TEST_N_LEVELS'th elements
**/
void FunctionalTest::calculateDimmensions(GLenum target, GLuint level, GLuint width, GLuint height, GLuint* out_widths,
GLuint* out_heights, GLuint* out_depths) const
{
GLuint divide = 100;
GLuint factors[FUNCTIONAL_TEST_N_LEVELS];
GLuint factor = divide;
const bool is_multi_layer = Utils::isTargetMultilayer(target);
const GLuint n_layers = (true == is_multi_layer) ? FUNCTIONAL_TEST_N_LAYERS : 1;
for (GLint i = (GLint)level; i >= 0; --i)
{
factors[i] = factor;
factor *= 2;
}
factor = divide / 2;
for (GLuint i = level + 1; i < FUNCTIONAL_TEST_N_LEVELS; ++i)
{
factors[i] = factor;
factor /= 2;
}
for (GLuint i = 0; i < FUNCTIONAL_TEST_N_LEVELS; ++i)
{
out_widths[i] = width * factors[i] / divide;
out_heights[i] = height * factors[i] / divide;
if (GL_TEXTURE_3D == target)
{
out_depths[i] = FUNCTIONAL_TEST_N_LAYERS * factors[i] / divide;
}
else
{
out_depths[i] = n_layers;
}
}
}
/** Execute copyImageSubData for given test case and verify results
*
* @param test_case Test case
* @param dst_pixels Data of destination image
* @param src_pixels Data of source image
*
* @return true if there is no error and results match expectations, false otherwise
**/
bool FunctionalTest::copyAndVerify(const testCase& test_case, const GLubyte** dst_pixels, const GLubyte** src_pixels)
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
GLuint region_depth = 1;
GLuint dst_layer_step = 0;
const bool is_dst_multi_layer = Utils::isTargetMultilayer(test_case.m_dst.m_target);
const bool is_src_multi_layer = Utils::isTargetMultilayer(test_case.m_src.m_target);
bool result = false;
GLuint src_layer_step = 0;
GLuint n_layers = 1;
/* Configure layers */
if ((true == is_dst_multi_layer) || (true == is_src_multi_layer))
{
if (is_src_multi_layer == is_dst_multi_layer)
{
/* Both objects are multilayered, copy all layers at once, verify at once */
region_depth = FUNCTIONAL_TEST_N_LAYERS;
}
else if (true == is_dst_multi_layer)
{
/* Destination is multilayered, copy each layer separetly, verify at once */
n_layers = FUNCTIONAL_TEST_N_LAYERS;
dst_layer_step = 1;
}
else
{
/* Destination is multilayered, copy and verify each layer separetly */
n_layers = FUNCTIONAL_TEST_N_LAYERS;
src_layer_step = 1;
}
}
/* Copy and verification */
{
GLuint dst_layer = 0;
GLuint src_layer = 0;
/* For each layer */
for (GLuint layer = 0; layer < n_layers; ++layer)
{
if (0 == m_rb_name)
{
gl.copyImageSubData(m_src_tex_name, test_case.m_src.m_target, test_case.m_src.m_level,
test_case.m_src_x, test_case.m_src_y, src_layer, m_dst_tex_name,
test_case.m_dst.m_target, test_case.m_dst.m_level, test_case.m_dst_x,
test_case.m_dst_y, dst_layer, test_case.m_width, test_case.m_height, region_depth);
}
else /* Copy from src to rb and from rb to dst */
{
/* Src and rb shares differs only on target */
gl.copyImageSubData(m_src_tex_name, GL_TEXTURE_2D, test_case.m_src.m_level, test_case.m_src_x,
test_case.m_src_y, src_layer, m_rb_name, test_case.m_src.m_target,
test_case.m_src.m_level, test_case.m_src_x, test_case.m_src_y, src_layer,
test_case.m_width, test_case.m_height, region_depth);
gl.copyImageSubData(m_rb_name, test_case.m_src.m_target, test_case.m_src.m_level, test_case.m_src_x,
test_case.m_src_y, src_layer, m_dst_tex_name, test_case.m_dst.m_target,
test_case.m_dst.m_level, test_case.m_dst_x, test_case.m_dst_y, dst_layer,
test_case.m_width, test_case.m_height, region_depth);
}
/* Verify generated error */
error = gl.getError();
if (GL_NO_ERROR == error)
{
/* Verify copy results */
result = verify(test_case, dst_layer, dst_pixels, src_layer, src_pixels, region_depth);
}
if ((GL_NO_ERROR != error) || (false == result))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "Failure. Targets src: " << glu::getTextureTargetStr(test_case.m_src.m_target)
<< ", dst: " << glu::getTextureTargetStr(test_case.m_dst.m_target)
<< ". Levels src: " << test_case.m_src.m_level << ", dst: " << test_case.m_dst.m_level
<< ". Dimmensions src [" << test_case.m_src.m_width << ", " << test_case.m_src.m_height
<< "], dst [" << test_case.m_dst.m_width << ", " << test_case.m_dst.m_height << "]. Region ["
<< test_case.m_width << " x " << test_case.m_height << " x " << region_depth << "] from ["
<< test_case.m_src_x << ", " << test_case.m_src_y << ", " << src_layer << "] to ["
<< test_case.m_dst_x << ", " << test_case.m_dst_y << ", " << dst_layer
<< "]. Format src: " << glu::getInternalFormatParameterStr(test_case.m_src.m_internal_format)
<< ", dst: " << glu::getInternalFormatParameterStr(test_case.m_dst.m_internal_format)
<< tcu::TestLog::EndMessage;
if (GL_NO_ERROR != error)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Failed due to error: " << glu::getErrorStr(error)
<< tcu::TestLog::EndMessage;
TCU_FAIL("Copy operation failed");
}
return false;
}
/* Step one layer */
dst_layer += dst_layer_step;
src_layer += src_layer_step;
}
}
return true;
}
/** Cleans resources
*
**/
void FunctionalTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
if (0 != m_dst_buf_name)
{
gl.deleteBuffers(1, &m_dst_buf_name);
m_dst_buf_name = 0;
}
if (0 != m_rb_name)
{
gl.deleteRenderbuffers(1, &m_rb_name);
m_rb_name = 0;
}
if (0 != m_src_buf_name)
{
gl.deleteBuffers(1, &m_src_buf_name);
m_src_buf_name = 0;
}
}
/** Free memory allocated for images
*
* @param pixels Array of pointers to image data
**/
void FunctionalTest::cleanPixels(GLubyte** pixels) const
{
for (GLuint i = 0; i < FUNCTIONAL_TEST_N_LEVELS; ++i)
{
if (0 != pixels[i])
{
delete[] pixels[i];
pixels[i] = 0;
}
}
}
/** Compare two images
* @param left_desc Descriptor of left image
* @param left_data Data of left image
* @param left_x X of left image
* @param left_y Y of left image
* @param left_layer Layer of left image
* @param left_level Level of left image
* @param right_desc Descriptor of right image
* @param right_data Data of right image
* @param right_x X of right image
* @param right_y Y of right image
* @param right_layer Layer of right image
* @param right_level Level of right image
* @param region_width Width of region to compare
* @param region_height Height of region to compare
*
* @return true if images are considered idenctial, false otherwise
**/
bool FunctionalTest::compareImages(const targetDesc& left_desc, const GLubyte* left_data, GLuint left_x, GLuint left_y,
GLuint left_layer, GLuint left_level, const targetDesc& right_desc,
const glw::GLubyte* right_data, GLuint right_x, GLuint right_y, GLuint right_layer,
GLuint right_level, GLuint region_width, GLuint region_height) const
{
/* Get level dimmensions */
GLuint left_heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint left_widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint left_depths[FUNCTIONAL_TEST_N_LEVELS];
GLuint right_heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint right_widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint right_depths[FUNCTIONAL_TEST_N_LEVELS];
calculateDimmensions(left_desc.m_target, left_desc.m_level, left_desc.m_width, left_desc.m_height, left_widths,
left_heights, left_depths);
calculateDimmensions(right_desc.m_target, right_desc.m_level, right_desc.m_width, right_desc.m_height, right_widths,
right_heights, right_depths);
/* Constants */
/* Dimmensions */
const GLuint left_height = left_heights[left_level];
const GLuint left_width = left_widths[left_level];
const GLuint right_height = right_heights[right_level];
const GLuint right_width = right_widths[right_level];
/* Sizes */
const GLuint left_pixel_size = Utils::getPixelSizeForFormat(left_desc.m_internal_format);
const GLuint left_line_size = left_pixel_size * left_width;
const GLuint left_layer_size = left_line_size * left_height;
const GLuint right_pixel_size = Utils::getPixelSizeForFormat(right_desc.m_internal_format);
const GLuint right_line_size = right_pixel_size * right_width;
const GLuint right_layer_size = right_line_size * right_height;
/* Offsets */
const GLuint left_layer_offset = left_layer_size * left_layer;
const GLuint left_reg_line_offset = left_line_size * left_y;
const GLuint left_reg_pix_offset = left_pixel_size * left_x;
const GLuint right_layer_offset = right_layer_size * right_layer;
const GLuint right_reg_line_offset = right_line_size * right_y;
const GLuint right_reg_pix_offset = right_pixel_size * right_x;
/* Pointers */
const GLubyte* left_layer_data = left_data + left_layer_offset;
const GLubyte* right_layer_data = right_data + right_layer_offset;
/* For each line of region */
for (GLuint y = 0; y < region_height; ++y)
{
/* Offsets */
const GLuint left_line_offset = left_reg_line_offset + y * left_line_size;
const GLuint right_line_offset = right_reg_line_offset + y * right_line_size;
/* Pointers */
const GLubyte* left_line_data = left_layer_data + left_line_offset;
const GLubyte* right_line_data = right_layer_data + right_line_offset;
/* For each pixel of region */
for (GLuint x = 0; x < region_width; ++x)
{
/* Offsets */
const GLuint left_pixel_offset = left_reg_pix_offset + x * left_pixel_size;
const GLuint right_pixel_offset = right_reg_pix_offset + x * right_pixel_size;
/* Pointers */
const GLubyte* left_pixel_data = left_line_data + left_pixel_offset;
const GLubyte* right_pixel_data = right_line_data + right_pixel_offset;
/* Compare */
if (false == Utils::comparePixels(left_pixel_size, left_pixel_data, right_pixel_size, right_pixel_data))
{
if (false == Utils::unpackAndComaprePixels(left_desc.m_format, left_desc.m_type,
left_desc.m_internal_format, left_pixel_data,
right_desc.m_format, right_desc.m_type,
right_desc.m_internal_format, right_pixel_data))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Not matching pixels found. Left: [" << x + left_x << ", "
<< y + left_y << ", " << left_layer << "] lvl:" << left_level
<< ", off: " << left_pixel_data - left_data
<< ", data: " << Utils::getPixelString(left_desc.m_internal_format, left_pixel_data)
<< ". Right: [" << x + right_x << ", " << y + right_y << ", " << right_layer
<< "] lvl: " << right_level << ", off: " << right_pixel_data - right_data
<< ", data: " << Utils::getPixelString(right_desc.m_internal_format, right_pixel_data)
<< tcu::TestLog::EndMessage;
return false;
}
}
}
}
return true;
}
/** Prepare regions that should not be modified during test case
*
* @param test_case Test case descriptor
* @param dst_level Level of destination image
* @param out_regions Number of regions
* @param out_n_regions Regions
**/
void FunctionalTest::getCleanRegions(const testCase& test_case, GLuint dst_level, GLuint out_regions[4][4],
GLuint& out_n_regions) const
{
GLuint dst_heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint dst_widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint dst_depths[FUNCTIONAL_TEST_N_LEVELS];
out_n_regions = 0;
calculateDimmensions(test_case.m_dst.m_target, dst_level, test_case.m_dst.m_width, test_case.m_dst.m_height,
dst_widths, dst_heights, dst_depths);
/* Constants */
/* Copied region */
const GLuint reg_x = test_case.m_dst_x;
const GLuint reg_y = test_case.m_dst_y;
const GLuint reg_w = test_case.m_width;
const GLuint reg_h = test_case.m_height;
const GLuint reg_r = reg_x + reg_w;
const GLuint reg_t = reg_y + reg_h;
/* Image */
const GLuint img_w = dst_widths[dst_level];
const GLuint img_h = dst_heights[dst_level];
/* Bottom row */
if (0 != reg_y)
{
out_regions[out_n_regions][0] = 0;
out_regions[out_n_regions][1] = 0;
out_regions[out_n_regions][2] = img_w;
out_regions[out_n_regions][3] = reg_y;
out_n_regions += 1;
}
/* Left edge */
if (0 != reg_x)
{
out_regions[out_n_regions][0] = 0;
out_regions[out_n_regions][1] = reg_y;
out_regions[out_n_regions][2] = reg_x;
out_regions[out_n_regions][3] = reg_h;
out_n_regions += 1;
}
/* Right edge */
if (img_w != reg_r)
{
out_regions[out_n_regions][0] = reg_r;
out_regions[out_n_regions][1] = reg_y;
out_regions[out_n_regions][2] = img_w - reg_r;
out_regions[out_n_regions][3] = reg_h;
out_n_regions += 1;
}
/* Top row */
if (img_h != reg_t)
{
out_regions[out_n_regions][0] = 0;
out_regions[out_n_regions][1] = reg_t;
out_regions[out_n_regions][2] = img_w;
out_regions[out_n_regions][3] = img_h - reg_t;
out_n_regions += 1;
}
}
/** Get pixel data for image
*
* @param name Name of image
* @param desc Descriptor of image
* @param level Level to capture
* @param out_pixels Pixels
**/
void FunctionalTest::getPixels(GLuint name, const targetDesc& desc, GLuint level, GLubyte* out_pixels) const
{
const Functions& gl = m_context.getRenderContext().getFunctions();
gl.bindTexture(desc.m_target, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.getTexImage(desc.m_target, level, desc.m_format, desc.m_type, out_pixels);
GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage");
gl.bindTexture(desc.m_target, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
}
/** Prepare data for destination image
*
* @param desc Descriptor
* @param out_pixels Array of pointer to image data
**/
void FunctionalTest::prepareDstPxls(const FunctionalTest::targetDesc& desc, GLubyte** out_pixels) const
{
const GLenum internal_format = desc.m_internal_format;
const bool is_multi_level = Utils::isTargetMultilevel(desc.m_target);
GLuint n_levels = 1;
const GLuint pixel_size = Utils::getPixelSizeForFormat(desc.m_internal_format);
const GLenum type = desc.m_type;
/* Configure levels */
if (true == is_multi_level)
{
n_levels = FUNCTIONAL_TEST_N_LEVELS;
}
/* Calculate dimmensions */
GLuint heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint depths[FUNCTIONAL_TEST_N_LEVELS];
calculateDimmensions(desc.m_target, desc.m_level, desc.m_width, desc.m_height, widths, heights, depths);
/* Prepare storage */
for (GLuint i = 0; i < n_levels; ++i)
{
const GLuint req_memory_per_layer = pixel_size * widths[i] * heights[i];
const GLuint req_memory_for_level = req_memory_per_layer * depths[i];
out_pixels[i] = new GLubyte[req_memory_for_level];
if (0 == out_pixels[i])
{
TCU_FAIL("Memory allocation failed");
}
memset(out_pixels[i], 0, req_memory_for_level);
}
/* Fill pixels */
for (GLuint i = 0; i < n_levels; ++i)
{
const GLuint n_layers = depths[i];
const GLuint n_pixels = widths[i] * heights[i];
GLubyte* ptr = (GLubyte*)out_pixels[i];
for (GLuint j = 0; j < n_pixels * n_layers; ++j)
{
GLubyte* pixel_data = ptr + j * pixel_size;
Utils::packPixel(internal_format, type, 1.0, 1.0, 1.0, 1.0, pixel_data);
}
}
}
/** Prepare data for source image
*
* @param desc Descriptor
* @param dst_internal_format Internal format of destination image
* @param out_pixels Array of pointer to image data
**/
void FunctionalTest::prepareSrcPxls(const FunctionalTest::targetDesc& desc, GLenum /* dst_internal_format */,
GLubyte** out_pixels) const
{
const GLenum internal_format = desc.m_internal_format;
const bool is_multi_level = Utils::isTargetMultilevel(desc.m_target);
GLuint n_levels = 1;
const GLuint pixel_size = Utils::getPixelSizeForFormat(desc.m_internal_format);
const GLenum type = desc.m_type;
/* Configure levels */
if (true == is_multi_level)
{
n_levels = FUNCTIONAL_TEST_N_LEVELS;
}
/* Calculate dimmensions */
GLuint heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint depths[FUNCTIONAL_TEST_N_LEVELS];
calculateDimmensions(desc.m_target, desc.m_level, desc.m_width, desc.m_height, widths, heights, depths);
/* Prepare storage */
for (GLuint i = 0; i < n_levels; ++i)
{
const GLuint req_memory_per_layer = pixel_size * widths[i] * heights[i];
const GLuint req_memory_for_level = req_memory_per_layer * depths[i];
out_pixels[i] = new GLubyte[req_memory_for_level];
if (0 == out_pixels[i])
{
TCU_FAIL("Memory allocation failed");
}
memset(out_pixels[i], 0, req_memory_for_level);
}
for (GLuint lvl = 0; lvl < n_levels; ++lvl)
{
const GLuint n_layers = depths[lvl];
const GLuint line_size = pixel_size * widths[lvl];
const GLuint req_memory_per_layer = line_size * heights[lvl];
GLubyte* level = (GLubyte*)out_pixels[lvl];
for (GLuint lay = 0; lay < n_layers; ++lay)
{
const GLuint layer_offset = lay * req_memory_per_layer;
GLubyte* layer = ((GLubyte*)level) + layer_offset;
for (GLuint y = 0; y < heights[lvl]; ++y)
{
const GLuint line_offset = line_size * y;
GLubyte* line = layer + line_offset;
for (GLuint x = 0; x < widths[lvl]; ++x)
{
const GLuint pixel_offset = x * pixel_size;
GLubyte* pixel = line + pixel_offset;
/* 255 is max ubyte. 1/15.9375 = 16/255 */
const GLdouble red = ((GLdouble)x) / 255.0 + (((GLdouble)y) / 15.9375);
const GLdouble green = ((GLdouble)lay) / 255.0 + (((GLdouble)lvl) / 15.9375);
const GLdouble blue = 0.125;
const GLdouble alpha = 1.0; /* This value has special meaning for some internal_formats */
Utils::packPixel(internal_format, type, red, green, blue, alpha, pixel);
}
}
}
}
}
/** Prepare test cases for given targets and internal formats
*
* @param dst_internal_format Internal format of destination image
* @param dst_target Target of destination image
* @param src_internal_format Internal format of source image
* @param src_target Target of source image
**/
void FunctionalTest::prepareTestCases(GLenum dst_internal_format, GLenum dst_target, GLenum src_internal_format,
GLenum src_target)
{
static const GLuint image_dimmensions[] = {
7,
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_IMG_DIM
8,
9,
10,
11,
12,
13,
14,
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_IMG_DIM */
15
};
static const GLuint region_dimmensions[] = {
1,
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_DIM
2,
3,
4,
5,
6,
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_DIM */
7
};
static const GLuint n_image_dimmensions = sizeof(image_dimmensions) / sizeof(image_dimmensions[0]);
static const GLuint n_region_dimmensions = sizeof(region_dimmensions) / sizeof(region_dimmensions[0]);
const bool is_dst_multi_level = Utils::isTargetMultilevel(dst_target);
const bool is_src_multi_level = Utils::isTargetMultilevel(src_target);
const GLenum dst_format = Utils::getFormat(dst_internal_format);
const GLuint dst_n_levels = (true == is_dst_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
const GLenum dst_type = Utils::getType(dst_internal_format);
const GLenum src_format = Utils::getFormat(src_internal_format);
const GLuint src_n_levels = (true == is_src_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
const GLenum src_type = Utils::getType(src_internal_format);
for (GLuint src_level = 0; src_level < src_n_levels; ++src_level)
{
for (GLuint dst_level = 0; dst_level < dst_n_levels; ++dst_level)
{
for (GLuint src_img_dim_id = 0; src_img_dim_id < n_image_dimmensions; ++src_img_dim_id)
{
const GLuint src_image_dimmension = image_dimmensions[src_img_dim_id];
for (GLuint dst_img_dim_id = 0; dst_img_dim_id < n_image_dimmensions; ++dst_img_dim_id)
{
const GLuint dst_image_dimmension = image_dimmensions[dst_img_dim_id];
for (GLuint reg_dim_id = 0; reg_dim_id < n_region_dimmensions; ++reg_dim_id)
{
const GLuint region_dimmension = region_dimmensions[reg_dim_id];
GLuint dst_coord[3] = { 0, 0, 0 };
const GLuint dst_dim_diff = dst_image_dimmension - region_dimmension;
GLuint n_dst_coords = 1;
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS
GLuint n_src_coords = 1;
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS */
GLuint src_coord[3] = { 0, 0, 0 };
const GLuint src_dim_diff = src_image_dimmension - region_dimmension;
/* Calculate coords */
if (1 == dst_dim_diff)
{
dst_coord[1] = 1;
n_dst_coords = 2;
}
else if (1 < dst_dim_diff)
{
dst_coord[1] = dst_dim_diff / 2;
dst_coord[2] = dst_dim_diff;
n_dst_coords = 3;
}
if (1 == src_dim_diff)
{
src_coord[1] = 1;
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS
n_src_coords = 2;
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS */
}
else if (1 < src_dim_diff)
{
src_coord[1] = src_dim_diff / 2;
src_coord[2] = src_dim_diff;
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS
n_src_coords = 3;
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS */
}
testCase test_case = {
{ /* m_dst */
dst_target, dst_image_dimmension, /* width */
dst_image_dimmension, /* height */
dst_level, dst_internal_format, dst_format, dst_type },
0, /* dst_x */
0, /* dst_y */
{ /* m_src */
src_target, src_image_dimmension, /* width */
src_image_dimmension, /* height */
src_level, src_internal_format, src_format, src_type },
0, /* src_x */
0, /* src_y */
region_dimmension, /* width */
region_dimmension, /* height */
};
#if COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS
for (GLuint src_x = 0; src_x < n_src_coords; ++src_x)
{
for (GLuint src_y = 0; src_y < n_src_coords; ++src_y)
{
for (GLuint dst_x = 0; dst_x < n_dst_coords; ++dst_x)
{
for (GLuint dst_y = 0; dst_y < n_dst_coords; ++dst_y)
{
test_case.m_dst_x = dst_coord[dst_x];
test_case.m_dst_y = dst_coord[dst_y];
test_case.m_src_x = src_coord[src_x];
test_case.m_src_y = src_coord[src_y];
m_test_cases.push_back(test_case);
}
}
}
}
#else /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS */
test_case.m_dst_x = dst_coord[n_dst_coords - 1];
test_case.m_dst_y = dst_coord[n_dst_coords - 1];
test_case.m_src_x = src_coord[0];
test_case.m_src_y = src_coord[0];
m_test_cases.push_back(test_case);
#endif /* COPY_IMAGE_FUNCTIONAL_TEST_ENABLE_ALL_REG_POS */
/* Whole image, for non 7x7 */
if ((dst_image_dimmension == src_image_dimmension) &&
(image_dimmensions[0] != dst_image_dimmension))
{
test_case.m_dst_x = 0;
test_case.m_dst_y = 0;
test_case.m_src_x = 0;
test_case.m_src_y = 0;
test_case.m_width = dst_image_dimmension;
test_case.m_height = dst_image_dimmension;
m_test_cases.push_back(test_case);
}
}
}
}
}
}
}
/** Prepare texture
*
* @param desc Descriptor
* @param pixels Image data
* @param out_buf_id Id of buffer used by texture buffer
*
* @return Name of iamge
**/
GLuint FunctionalTest::prepareTexture(const targetDesc& desc, const GLubyte** pixels, GLuint& out_buf_id)
{
GLuint name = Utils::generateTexture(m_context, desc.m_target);
if (false == Utils::isTargetMultilevel(desc.m_target))
{
Utils::prepareTexture(m_context, name, desc.m_target, desc.m_internal_format, desc.m_format, desc.m_type,
0 /* level */, desc.m_width, desc.m_height,
FUNCTIONAL_TEST_N_LAYERS /* depth - 12 for multilayered, 1D and 2D will ignore that */,
pixels[0], out_buf_id);
Utils::makeTextureComplete(m_context, desc.m_target, name, 0 /* base */, 0 /* max */);
}
else
{
/* Calculate dimmensions */
GLuint heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint depths[FUNCTIONAL_TEST_N_LEVELS];
calculateDimmensions(desc.m_target, desc.m_level, desc.m_width, desc.m_height, widths, heights, depths);
for (GLuint level = 0; level < FUNCTIONAL_TEST_N_LEVELS; ++level)
{
Utils::prepareTexture(m_context, name, desc.m_target, desc.m_internal_format, desc.m_format, desc.m_type,
level, widths[level], heights[level], depths[level], pixels[level], out_buf_id);
Utils::makeTextureComplete(m_context, desc.m_target, name, 0 /* base */, 2 /* max */);
}
}
return name;
}
/** Verify copy operation
*
* @param test_case Test case
* @param dst_layer First layer modified by copy
* @param dst_pixels Origiranl data of destination image
* @param src_layer First layer read by copy
* @param src_pixels Original data of source image
* @param depth Number of copied layers
*
* @return true if everything is as expected, false otherwise
**/
bool FunctionalTest::verify(const testCase& test_case, GLuint dst_layer, const GLubyte** dst_pixels, GLuint src_layer,
const GLubyte** src_pixels, GLuint depth)
{
const bool is_dst_multi_level = Utils::isTargetMultilevel(test_case.m_dst.m_target);
const bool is_src_multi_level = Utils::isTargetMultilevel(test_case.m_src.m_target);
const GLuint dst_level = test_case.m_dst.m_level;
std::vector<GLubyte> dst_level_data;
const GLuint dst_pixel_size = Utils::getPixelSizeForFormat(test_case.m_dst.m_internal_format);
targetDesc src_desc = test_case.m_src;
const GLuint src_level = src_desc.m_level;
std::vector<GLubyte> src_level_data;
const GLuint src_pixel_size = Utils::getPixelSizeForFormat(src_desc.m_internal_format);
if (0 != m_rb_name)
{
src_desc.m_target = GL_TEXTURE_2D;
}
/* Calculate storage requirements */
GLuint dst_req_mem_per_layer[FUNCTIONAL_TEST_N_LEVELS];
GLuint dst_heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint dst_widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint dst_depths[FUNCTIONAL_TEST_N_LEVELS];
GLuint src_req_mem_per_layer[FUNCTIONAL_TEST_N_LEVELS];
GLuint src_heights[FUNCTIONAL_TEST_N_LEVELS];
GLuint src_widths[FUNCTIONAL_TEST_N_LEVELS];
GLuint src_depths[FUNCTIONAL_TEST_N_LEVELS];
calculateDimmensions(test_case.m_dst.m_target, dst_level, test_case.m_dst.m_width, test_case.m_dst.m_height,
dst_widths, dst_heights, dst_depths);
calculateDimmensions(src_desc.m_target, src_level, src_desc.m_width, src_desc.m_height, src_widths, src_heights,
src_depths);
for (GLuint i = 0; i < FUNCTIONAL_TEST_N_LEVELS; ++i)
{
dst_req_mem_per_layer[i] = dst_widths[i] * dst_heights[i] * dst_pixel_size;
src_req_mem_per_layer[i] = src_widths[i] * src_heights[i] * src_pixel_size;
}
/* Prepare storage, use 0 level as it is the biggest one */
dst_level_data.resize(dst_req_mem_per_layer[0] * dst_depths[0]);
src_level_data.resize(src_req_mem_per_layer[0] * src_depths[0]);
/* Verification of contents
* - source image - expect no modification
* - destination image, mipmap before and after dst_level - expect no modification
* - destination image, mipmap at dst_level:
* * layers after dst_layer + depth - expect no modification
* * layers <0, dst_layer + depth> - expect that contents at selected region were copied
*/
/* Check if source image was not modified */
{
const GLuint n_levels = (true == is_src_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
for (GLuint level = 0; level < n_levels; ++level)
{
getPixels(m_src_tex_name, src_desc, level, &src_level_data[0]);
for (GLuint layer = 0; layer < src_depths[level]; ++layer)
{
if (false == compareImages(src_desc, src_pixels[level], 0, 0, layer, level, src_desc,
&src_level_data[0], 0, 0, layer, level, src_widths[level],
src_heights[level]))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "CopyImageSubData modified contents of source image. Original data: left."
<< tcu::TestLog::EndMessage;
return false;
}
}
}
}
/* Check if contents of destination at levels != dst_level were not modified */
{
const GLuint n_levels = (true == is_dst_multi_level) ? FUNCTIONAL_TEST_N_LEVELS : 1;
for (GLuint level = 0; level < n_levels; ++level)
{
if (dst_level == level)
{
continue;
}
getPixels(m_dst_tex_name, test_case.m_dst, level, &dst_level_data[0]);
for (GLuint layer = 0; layer < dst_depths[level]; ++layer)
{
if (false == compareImages(test_case.m_dst, dst_pixels[level], 0, 0, layer, level, test_case.m_dst,
&dst_level_data[0], 0, 0, layer, level, dst_widths[level],
dst_heights[level]))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "CopyImageSubData modified contents of wrong mipmap level. Original data: left."
<< tcu::TestLog::EndMessage;
return false;
}
}
}
}
/* Check contents of modified level */
{
getPixels(m_dst_tex_name, test_case.m_dst, dst_level, &dst_level_data[0]);
/* Check anything after dst_layer + depth */
{
for (GLuint layer = dst_layer + depth; layer < dst_depths[dst_level]; ++layer)
{
if (false == compareImages(test_case.m_dst, dst_pixels[dst_level], 0, 0, layer, dst_level,
test_case.m_dst, &dst_level_data[0], 0, 0, layer, dst_level,
dst_widths[dst_level], dst_heights[dst_level]))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "CopyImageSubData modified contents of wrong layer. Original data: left."
<< tcu::TestLog::EndMessage;
return false;
}
}
}
/* Check modified layers */
for (GLuint layer = 0; layer < depth; ++layer)
{
/* Check contents outside of copied region */
{
GLuint n_regions = 0;
GLuint regions[4][4] = { { 0 } };
getCleanRegions(test_case, dst_level, regions, n_regions);
for (GLuint region = 0; region < n_regions; ++region)
{
const GLuint x = regions[region][0];
const GLuint y = regions[region][1];
const GLuint w = regions[region][2];
const GLuint h = regions[region][3];
if (false == compareImages(test_case.m_dst, dst_pixels[dst_level], x, y, layer + dst_layer,
dst_level, test_case.m_dst, &dst_level_data[0], x, y, layer + dst_layer,
dst_level, w, h))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "CopyImageSubData modified contents outside of copied region. Original data: left."
<< tcu::TestLog::EndMessage;
return false;
}
}
}
/* Check contents of copied region */
if (false == compareImages(test_case.m_dst, &dst_level_data[0], test_case.m_dst_x, test_case.m_dst_y,
layer + dst_layer, dst_level, src_desc, src_pixels[src_level], test_case.m_src_x,
test_case.m_src_y, layer + src_layer, src_level, test_case.m_width,
test_case.m_height))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "CopyImageSubData stored invalid data in copied region. Destination data: left."
<< tcu::TestLog::EndMessage;
return false;
}
}
}
return true;
}
/* SmokeTest */
/* Constants */
const GLuint SmokeTest::m_width = 16;
const GLuint SmokeTest::m_height = 16;
const GLuint SmokeTest::m_depth = 1;
/** Constructor
*
* @param context Text context
**/
SmokeTest::SmokeTest(deqp::Context& context)
: TestCase(context, "smoke_test", "Test tries all formats and targets")
, m_dst_buf_name(0)
, m_dst_tex_name(0)
, m_rb_name(0)
, m_src_buf_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
/* Iterate over valid targets */
for (GLuint tgt_id = 0; tgt_id < s_n_valid_targets; ++tgt_id)
{
const GLenum target = s_valid_targets[tgt_id];
if (true == Utils::isTargetMultisampled(target))
{
continue;
}
const testCase test_case = { target, GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT };
m_test_cases.push_back(test_case);
}
/* Iterate over internal formats */
for (GLuint fmt_id = 0; fmt_id < s_n_internal_formats; ++fmt_id)
{
const GLenum internal_format = s_internal_formats[fmt_id];
const GLenum format = Utils::getFormat(internal_format);
const GLenum type = Utils::getType(internal_format);
const testCase test_case = { GL_TEXTURE_2D, internal_format, format, type };
m_test_cases.push_back(test_case);
}
}
/** Cleans resources
*
**/
void SmokeTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
if (0 != m_dst_buf_name)
{
gl.deleteBuffers(1, &m_dst_buf_name);
m_dst_buf_name = 0;
}
if (0 != m_rb_name)
{
gl.deleteRenderbuffers(1, &m_rb_name);
m_rb_name = 0;
}
if (0 != m_src_buf_name)
{
gl.deleteBuffers(1, &m_src_buf_name);
m_src_buf_name = 0;
}
}
/** Free memory allocated for images
*
* @param pixels Pointers to image data
**/
void SmokeTest::cleanPixels(GLubyte*& pixels) const
{
if (0 == pixels)
{
return;
}
delete[] pixels;
pixels = 0;
}
/** Compare two images
* @param test_case Test case descriptor
* @param left_data Data of left image
* @param right_data Data of right image
*
* @return true if images are considered idenctial, false otherwise
**/
bool SmokeTest::compareImages(const testCase& test_case, const GLubyte* left_data, const GLubyte* right_data) const
{
/* Constants */
/* Sizes */
const GLuint pixel_size = Utils::getPixelSizeForFormat(test_case.m_internal_format);
const GLuint line_size = pixel_size * m_width;
GLuint height = m_height;
if ((GL_TEXTURE_1D == test_case.m_target) || (GL_TEXTURE_1D_ARRAY == test_case.m_target))
{
height = 1;
}
/* For each line */
for (GLuint y = 0; y < height; ++y)
{
/* Offsets */
const GLuint line_offset = y * line_size;
/* Pointers */
const GLubyte* left_line_data = left_data + line_offset;
const GLubyte* right_line_data = right_data + line_offset;
/* For each pixel of region */
for (GLuint x = 0; x < m_width; ++x)
{
/* Offsets */
const GLuint pixel_offset = x * pixel_size;
/* Pointers */
const GLubyte* left_pixel_data = left_line_data + pixel_offset;
const GLubyte* right_pixel_data = right_line_data + pixel_offset;
/* Compare */
if (false == Utils::comparePixels(pixel_size, left_pixel_data, pixel_size, right_pixel_data))
{
if (false == Utils::unpackAndComaprePixels(
test_case.m_format, test_case.m_type, test_case.m_internal_format, left_pixel_data,
test_case.m_format, test_case.m_type, test_case.m_internal_format, right_pixel_data))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Not matching pixels found. "
<< "[" << x << ", " << y << "], off: " << left_pixel_data - left_data
<< ". Data left: " << Utils::getPixelString(test_case.m_internal_format, left_pixel_data)
<< ", right: " << Utils::getPixelString(test_case.m_internal_format, right_pixel_data)
<< tcu::TestLog::EndMessage;
return false;
}
}
}
}
return true;
}
/** Execute copyImageSubData for given test case and verify results
*
* @param test_case Test case
* @param src_pixels Data of source image
*
* @return true if there is no error and results match expectations, false otherwise
**/
bool SmokeTest::copyAndVerify(const testCase& test_case, const GLubyte* src_pixels)
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
bool result = false;
/* Copy and verification */
{
if (0 == m_rb_name)
{
GLuint height = m_height;
if ((GL_TEXTURE_1D == test_case.m_target) || (GL_TEXTURE_1D_ARRAY == test_case.m_target))
{
height = 1;
}
gl.copyImageSubData(m_src_tex_name, test_case.m_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, m_width, height, m_depth);
}
else /* Copy from src to rb and from rb to dst */
{
/* Src and rb shares differs only on target */
gl.copyImageSubData(m_src_tex_name, GL_TEXTURE_2D, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_rb_name, test_case.m_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, m_width, m_height, m_depth);
gl.copyImageSubData(m_rb_name, test_case.m_target, 0 /* dstLevel */, 0 /* dstX */, 0 /* dstY */,
0 /* dstZ */, m_dst_tex_name, GL_TEXTURE_2D, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, m_width, m_height, m_depth);
}
/* Verify generated error */
error = gl.getError();
if (GL_NO_ERROR == error)
{
/* Verify copy results */
result = verify(test_case, src_pixels);
}
if ((GL_NO_ERROR != error) || (false == result))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Target: " << glu::getTextureTargetStr(test_case.m_target)
<< ". Format: " << glu::getInternalFormatParameterStr(test_case.m_internal_format)
<< tcu::TestLog::EndMessage;
if (GL_NO_ERROR != error)
{
m_context.getTestContext().getLog() << tcu::TestLog::Message
<< "Failed due to error: " << glu::getErrorStr(error)
<< tcu::TestLog::EndMessage;
TCU_FAIL("Copy operation failed");
}
return false;
}
}
return true;
}
/** Get pixel data for image
*
* @param name Name of image
* @param test_case Test case descriptor
* @param out_pixels Pixels
**/
void SmokeTest::getPixels(GLuint name, const SmokeTest::testCase& test_case, GLubyte* out_pixels) const
{
const Functions& gl = m_context.getRenderContext().getFunctions();
GLenum tgt_bind = test_case.m_target;
GLenum tgt_get = test_case.m_target;
if (GL_RENDERBUFFER == test_case.m_target)
{
tgt_bind = GL_TEXTURE_2D;
tgt_get = GL_TEXTURE_2D;
}
else if (GL_TEXTURE_CUBE_MAP == test_case.m_target)
{
tgt_get = GL_TEXTURE_CUBE_MAP_POSITIVE_X;
}
gl.bindTexture(tgt_bind, name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.getTexImage(tgt_get, 0 /* level */, test_case.m_format, test_case.m_type, out_pixels);
GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage");
gl.bindTexture(tgt_bind, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult SmokeTest::iterate()
{
GLubyte* dst_pixels = 0;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
GLubyte* src_pixels = 0;
const testCase& test_case = m_test_cases[m_test_case_index];
gl.pixelStorei(GL_PACK_ALIGNMENT, 1);
gl.pixelStorei(GL_UNPACK_ALIGNMENT, 1);
GLU_EXPECT_NO_ERROR(gl.getError(), "PixelStorei");
try
{
/* Prepare pixels */
prepareDstPxls(test_case, dst_pixels);
prepareSrcPxls(test_case, src_pixels);
/* Prepare textures */
if (GL_RENDERBUFFER == test_case.m_target)
{
testCase desc = test_case;
GLuint ignored = 0;
desc.m_target = GL_TEXTURE_2D;
m_rb_name = prepareTexture(test_case, 0 /* pixels */, ignored /* buffer name */);
m_dst_tex_name = prepareTexture(desc, dst_pixels, m_dst_buf_name);
m_src_tex_name = prepareTexture(desc, src_pixels, m_src_buf_name);
}
else
{
m_dst_tex_name = prepareTexture(test_case, dst_pixels, m_dst_buf_name);
m_src_tex_name = prepareTexture(test_case, src_pixels, m_src_buf_name);
}
/* Copy images and verify results */
result = copyAndVerify(test_case, src_pixels);
}
catch (tcu::Exception& exc)
{
clean();
cleanPixels(dst_pixels);
cleanPixels(src_pixels);
throw exc;
}
/* Free resources */
clean();
cleanPixels(dst_pixels);
cleanPixels(src_pixels);
/* Set result */
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Failure. " << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Prepare data for destination image
*
* @param test_case Test case descriptor
* @param out_pixels Pointer to image data
**/
void SmokeTest::prepareDstPxls(const SmokeTest::testCase& test_case, GLubyte*& out_pixels) const
{
static const GLuint n_pixels_per_layer = m_width * m_height;
const GLenum internal_format = test_case.m_internal_format;
const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
const GLuint n_pixels = n_pixels_per_layer * n_layers;
const GLuint pixel_size = Utils::getPixelSizeForFormat(internal_format);
const GLuint req_memory = pixel_size * n_pixels;
const GLenum type = test_case.m_type;
/* Prepare storage */
out_pixels = new GLubyte[req_memory];
if (0 == out_pixels)
{
TCU_FAIL("Memory allocation failed");
}
memset(out_pixels, 0, req_memory);
/* Fill pixels */
for (GLuint j = 0; j < n_pixels; ++j)
{
GLubyte* pixel_data = out_pixels + j * pixel_size;
Utils::packPixel(internal_format, type, 1.0, 1.0, 1.0, 1.0, pixel_data);
}
}
/** Prepare data for source image
*
* @param test_case Test case descriptor
* @param out_pixels Pointer to image data
**/
void SmokeTest::prepareSrcPxls(const SmokeTest::testCase& test_case, GLubyte*& out_pixels) const
{
static const GLuint n_pixels_per_layer = m_width * m_height;
const GLenum internal_format = test_case.m_internal_format;
const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
const GLuint n_pixels = n_pixels_per_layer * n_layers;
const GLuint pixel_size = Utils::getPixelSizeForFormat(internal_format);
const GLuint layer_size = pixel_size * n_pixels_per_layer;
const GLuint line_size = pixel_size * m_width;
const GLuint req_memory = pixel_size * n_pixels;
const GLenum type = test_case.m_type;
/* Prepare storage */
out_pixels = new GLubyte[req_memory];
if (0 == out_pixels)
{
TCU_FAIL("Memory allocation failed");
}
memset(out_pixels, 0, req_memory);
/* Fill pixels */
for (GLuint layer = 0; layer < n_layers; ++layer)
{
const GLuint layer_offset = layer * layer_size;
GLubyte* layer_data = out_pixels + layer_offset;
for (GLuint y = 0; y < m_height; ++y)
{
const GLuint line_offset = line_size * y;
GLubyte* line_data = layer_data + line_offset;
for (GLuint x = 0; x < m_width; ++x)
{
const GLuint pixel_offset = x * pixel_size;
GLubyte* pixel_data = line_data + pixel_offset;
/* 255 is max ubyte. 1/15.9375 = 16/255 */
const GLdouble red = ((GLdouble)x) / 255.0 + (((GLdouble)y) / 15.9375);
const GLdouble green = ((GLdouble)layer) / 255.0 + (1.0 / 15.9375);
const GLdouble blue = 0.125;
const GLdouble alpha = 1.0; /* This value has special meaning for some internal_formats */
Utils::packPixel(internal_format, type, red, green, blue, alpha, pixel_data);
}
}
}
}
/** Prepare texture
*
* @param desc Descriptor
* @param pixels Image data
* @param out_buf_id Id of buffer used by texture buffer
*
* @return Name of iamge
**/
GLuint SmokeTest::prepareTexture(const testCase& test_case, const GLubyte* pixels, GLuint& out_buf_id)
{
const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
GLuint name = Utils::generateTexture(m_context, test_case.m_target);
Utils::prepareTexture(m_context, name, test_case.m_target, test_case.m_internal_format, test_case.m_format,
test_case.m_type, 0 /* level */, m_width, m_height, n_layers, pixels, out_buf_id);
Utils::makeTextureComplete(m_context, test_case.m_target, name, 0 /* base */, 0 /* max */);
return name;
}
/** Verify copy operation
*
* @param test_case Test case
* @param src_pixels Original data of source image
*
* @return true if everything is as expected, false otherwise
**/
bool SmokeTest::verify(const testCase& test_case, const GLubyte* src_pixels)
{
std::vector<GLubyte> dst_data;
const GLuint n_layers = (GL_TEXTURE_CUBE_MAP_ARRAY != test_case.m_target) ? m_depth : 6;
const GLuint pixel_size = Utils::getPixelSizeForFormat(test_case.m_internal_format);
const GLuint line_size = pixel_size * m_width;
const GLuint req_memory = line_size * m_height * n_layers;
std::vector<GLubyte> src_data;
/* Prepare storage */
dst_data.resize(req_memory);
src_data.resize(req_memory);
/* Check if source image was not modified */
{
getPixels(m_src_tex_name, test_case, &src_data[0]);
if (false == compareImages(test_case, src_pixels, &src_data[0]))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "CopyImageSubData modified contents of source image. Original data: left."
<< tcu::TestLog::EndMessage;
return false;
}
}
/* Check contents of destination image */
{
getPixels(m_dst_tex_name, test_case, &dst_data[0]);
if (false == compareImages(test_case, src_pixels, &dst_data[0]))
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message
<< "CopyImageSubData stored invalid contents in destination image. Source data: left."
<< tcu::TestLog::EndMessage;
return false;
}
}
return true;
}
/* InvalidTargetTest */
/** Constructor
*
* @param context Text context
**/
InvalidTargetTest::InvalidTargetTest(deqp::Context& context)
: TestCase(context, "invalid_target",
"Test verifies if INVALID_ENUM is generated when invalid target is provided to CopyImageSubData")
, m_dst_buf_name(0)
, m_dst_tex_name(0)
, m_src_buf_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
/* Valid source, valid dst */
for (GLuint src = 0; src < s_n_valid_targets; ++src)
{
for (GLuint dst = 0; dst < s_n_valid_targets; ++dst)
{
const GLenum src_target = s_valid_targets[src];
const GLenum dst_target = s_valid_targets[dst];
testCase test_case = { src_target, dst_target, GL_NO_ERROR };
if (Utils::isTargetMultisampled(dst_target) != Utils::isTargetMultisampled(src_target))
{
test_case.m_expected_result = GL_INVALID_OPERATION;
}
m_test_cases.push_back(test_case);
}
}
/* Invalid source, invalid dst */
for (GLuint src = 0; src < s_n_invalid_targets; ++src)
{
for (GLuint dst = 0; dst < s_n_invalid_targets; ++dst)
{
const GLenum src_target = s_invalid_targets[src];
const GLenum dst_target = s_invalid_targets[dst];
const testCase test_case = { src_target, dst_target, GL_INVALID_ENUM };
m_test_cases.push_back(test_case);
}
}
/* Invalid source, valid dst */
for (GLuint src = 0; src < s_n_invalid_targets; ++src)
{
for (GLuint dst = 0; dst < s_n_valid_targets; ++dst)
{
const GLenum src_target = s_invalid_targets[src];
const GLenum dst_target = s_valid_targets[dst];
const testCase test_case = { src_target, dst_target, GL_INVALID_ENUM };
m_test_cases.push_back(test_case);
}
}
/* Valid source, invalid dst */
for (GLuint src = 0; src < s_n_valid_targets; ++src)
{
for (GLuint dst = 0; dst < s_n_invalid_targets; ++dst)
{
const GLenum src_target = s_valid_targets[src];
const GLenum dst_target = s_invalid_targets[dst];
const testCase test_case = { src_target, dst_target, GL_INVALID_ENUM };
m_test_cases.push_back(test_case);
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult InvalidTargetTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_dst_target, GL_RGBA8, GL_RGBA,
GL_UNSIGNED_BYTE, m_dst_buf_name);
m_src_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_src_target, GL_RGBA8, GL_RGBA,
GL_UNSIGNED_BYTE, m_src_buf_name);
/* Make textures complete */
Utils::makeTextureComplete(m_context, test_case.m_dst_target, m_dst_tex_name, 0 /* base */, 0 /* max */);
Utils::makeTextureComplete(m_context, test_case.m_src_target, m_src_tex_name, 0 /* base */, 0 /* max */);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_src_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_dst_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, 1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Free resources */
clean();
/* Set result */
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Source target: " << glu::getTextureTargetStr(test_case.m_src_target)
<< ", destination target: " << glu::getTextureTargetStr(test_case.m_dst_target) << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void InvalidTargetTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
const testCase& test_case = m_test_cases[m_test_case_index];
/* Clean textures and buffers. Errors ignored */
Utils::deleteTexture(m_context, test_case.m_dst_target, m_dst_tex_name);
Utils::deleteTexture(m_context, test_case.m_src_target, m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
if (0 != m_dst_buf_name)
{
gl.deleteBuffers(1, &m_dst_buf_name);
m_dst_buf_name = 0;
}
if (0 != m_src_buf_name)
{
gl.deleteBuffers(1, &m_src_buf_name);
m_src_buf_name = 0;
}
}
/* TargetMismatchTest */
/** Constructor
*
* @param context Text context
**/
TargetMismatchTest::TargetMismatchTest(deqp::Context& context)
: TestCase(
context, "target_miss_match",
"Test verifies if INVALID_ENUM is generated when target provided to CopyImageSubData does not match texture")
, m_dst_buf_name(0)
, m_dst_tex_name(0)
, m_src_buf_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
/* Wrong dst target */
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
for (GLuint dst = 0; dst < s_n_valid_targets; ++dst)
{
const GLenum dst_target = s_valid_targets[dst];
const GLenum src_target = s_valid_targets[target];
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, src_target, dst_target, GL_INVALID_ENUM };
/* Skip renderbuffers */
if ((GL_RENDERBUFFER == tex_target) || (GL_RENDERBUFFER == dst_target) || (GL_RENDERBUFFER == src_target))
{
continue;
}
/* Valid case */
if (dst_target == tex_target)
{
test_case.m_expected_result = GL_NO_ERROR;
}
/* Skip cases with multisampling conflict */
if (Utils::isTargetMultisampled(dst_target) != Utils::isTargetMultisampled(src_target))
{
continue;
}
m_test_cases.push_back(test_case);
}
}
/* Wrong src target */
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
for (GLuint src = 0; src < s_n_valid_targets; ++src)
{
const GLenum dst_target = s_valid_targets[target];
const GLenum src_target = s_valid_targets[src];
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, src_target, dst_target, GL_INVALID_ENUM };
/* Skip renderbuffers */
if ((GL_RENDERBUFFER == tex_target) || (GL_RENDERBUFFER == dst_target) || (GL_RENDERBUFFER == src_target))
{
continue;
}
/* Valid case */
if (src_target == tex_target)
{
test_case.m_expected_result = GL_NO_ERROR;
}
/* Skip cases with multisampling conflict */
if (Utils::isTargetMultisampled(dst_target) != Utils::isTargetMultisampled(src_target))
{
continue;
}
m_test_cases.push_back(test_case);
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult TargetMismatchTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA,
GL_UNSIGNED_BYTE, m_dst_buf_name);
m_src_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA,
GL_UNSIGNED_BYTE, m_src_buf_name);
/* Make textures complete */
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_dst_tex_name, 0 /* base */, 0 /* max */);
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_src_tex_name, 0 /* base */, 0 /* max */);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_src_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_dst_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, 1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Remove resources */
clean();
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Texture target: " << glu::getTextureTargetStr(test_case.m_tex_target)
<< ". Source target: " << glu::getTextureTargetStr(test_case.m_src_target)
<< ", destination target: " << glu::getTextureTargetStr(test_case.m_dst_target) << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void TargetMismatchTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
if (0 != m_dst_buf_name)
{
gl.deleteBuffers(1, &m_dst_buf_name);
m_dst_buf_name = 0;
}
if (0 != m_src_buf_name)
{
gl.deleteBuffers(1, &m_src_buf_name);
m_src_buf_name = 0;
}
}
/* TargetMismatchTest */
/** Constructor
*
* @param context Text context
**/
IncompleteTexTest::IncompleteTexTest(deqp::Context& context)
: TestCase(
context, "incomplete_tex",
"Test verifies if INVALID_OPERATION is generated when texture provided to CopyImageSubData is incomplete")
, m_dst_buf_name(0)
, m_dst_tex_name(0)
, m_src_buf_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, false, false, GL_INVALID_OPERATION };
/* Skip targets that are not multi level */
if (false == Utils::isTargetMultilevel(tex_target))
{
continue;
}
m_test_cases.push_back(test_case);
test_case.m_is_dst_complete = true;
test_case.m_is_src_complete = false;
m_test_cases.push_back(test_case);
test_case.m_is_dst_complete = false;
test_case.m_is_src_complete = true;
m_test_cases.push_back(test_case);
test_case.m_is_dst_complete = true;
test_case.m_is_src_complete = true;
test_case.m_expected_result = GL_NO_ERROR;
m_test_cases.push_back(test_case);
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult IncompleteTexTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA,
GL_UNSIGNED_BYTE, m_dst_buf_name);
m_src_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA,
GL_UNSIGNED_BYTE, m_src_buf_name);
/* Make textures complete */
if (true == test_case.m_is_dst_complete)
{
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_dst_tex_name, 0 /* base */, 0 /* max */);
}
if (true == test_case.m_is_src_complete)
{
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_src_tex_name, 0 /* base */, 0 /* max */);
}
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_tex_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_tex_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, 1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Remove resources */
clean();
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Texture target: " << glu::getTextureTargetStr(test_case.m_tex_target)
<< ". Is source complete: " << test_case.m_is_src_complete
<< ", is destination complete: " << test_case.m_is_dst_complete << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void IncompleteTexTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
if (0 != m_dst_buf_name)
{
gl.deleteBuffers(1, &m_dst_buf_name);
m_dst_buf_name = 0;
}
if (0 != m_src_buf_name)
{
gl.deleteBuffers(1, &m_src_buf_name);
m_src_buf_name = 0;
}
}
/* IncompatibleFormatsTest */
/** Constructor
*
* @param context Text context
**/
IncompatibleFormatsTest::IncompatibleFormatsTest(deqp::Context& context)
: TestCase(
context, "incompatible_formats",
"Test verifies if INVALID_OPERATION is generated when textures provided to CopyImageSubData are incompatible")
, m_dst_buf_name(0)
, m_dst_tex_name(0)
, m_src_buf_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
/* RGBA8UI vs RGBA16UI */
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE,
GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, GL_INVALID_OPERATION };
/* Skip multisampled and rectangle targets */
if (true == Utils::isTargetMultisampled(tex_target))
{
continue;
}
m_test_cases.push_back(test_case);
}
/* RGBA8UI vs RGBA32UI */
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, GL_RGBA8UI, GL_RGBA_INTEGER, GL_UNSIGNED_BYTE,
GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, GL_INVALID_OPERATION };
/* Skip multisampled and rectangle targets */
if (true == Utils::isTargetMultisampled(tex_target))
{
continue;
}
m_test_cases.push_back(test_case);
}
/* RGBA16UI vs RG16UI */
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT,
GL_RG16UI, GL_RG_INTEGER, GL_UNSIGNED_SHORT, GL_INVALID_OPERATION };
/* Skip multisampled and rectangle targets */
if (true == Utils::isTargetMultisampled(tex_target))
{
continue;
}
m_test_cases.push_back(test_case);
}
/* RGBA32UI vs RGBA32F */
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT,
GL_RGBA32F, GL_RGBA, GL_FLOAT, GL_NO_ERROR };
/* Skip multisampled and rectangle targets */
if (true == Utils::isTargetMultisampled(tex_target))
{
continue;
}
m_test_cases.push_back(test_case);
}
/* RGBA8 vs RGBA32F */
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE,
GL_RGBA32F, GL_RGBA, GL_FLOAT, GL_INVALID_OPERATION };
/* Skip multisampled and rectangle targets */
if (true == Utils::isTargetMultisampled(tex_target))
{
continue;
}
m_test_cases.push_back(test_case);
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult IncompatibleFormatsTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, test_case.m_dst_internal_format,
test_case.m_dst_format, test_case.m_dst_type, m_dst_buf_name);
m_src_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, test_case.m_src_internal_format,
test_case.m_src_format, test_case.m_src_type, m_src_buf_name);
/* Make textures complete */
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_dst_tex_name, 0 /* base */, 0 /* max */);
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_src_tex_name, 0 /* base */, 0 /* max */);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_tex_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_tex_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, 1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Remove resources */
clean();
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Texture target: " << glu::getTextureTargetStr(test_case.m_tex_target)
<< ". Source format: " << glu::getInternalFormatParameterStr(test_case.m_src_internal_format)
<< ". Destination format: " << glu::getInternalFormatParameterStr(test_case.m_dst_internal_format)
<< tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void IncompatibleFormatsTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
const testCase& test_case = m_test_cases[m_test_case_index];
/* Clean textures and buffers. Errors ignored */
Utils::deleteTexture(m_context, test_case.m_tex_target, m_dst_tex_name);
Utils::deleteTexture(m_context, test_case.m_tex_target, m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
if (0 != m_dst_buf_name)
{
gl.deleteBuffers(1, &m_dst_buf_name);
m_dst_buf_name = 0;
}
if (0 != m_src_buf_name)
{
gl.deleteBuffers(1, &m_src_buf_name);
m_src_buf_name = 0;
}
}
/* InvalidTargetTest */
/** Constructor
*
* @param context Text context
**/
SamplesMismatchTest::SamplesMismatchTest(deqp::Context& context)
: TestCase(context, "samples_mismatch", "Test verifies if INVALID_OPERATION is generated when textures provided "
"to CopyImageSubData have different number of samples")
, m_dst_tex_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
testCase test_case;
static const GLsizei n_samples[2] = { 1, 4 };
static const GLenum targets[2] = { GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_MULTISAMPLE_ARRAY };
for (GLuint src_sample = 0; src_sample < 2; ++src_sample)
{
for (GLuint dst_sample = 0; dst_sample < 2; ++dst_sample)
{
for (GLuint src_target = 0; src_target < 2; ++src_target)
{
for (GLuint dst_target = 0; dst_target < 2; ++dst_target)
{
test_case.m_src_target = targets[src_target];
test_case.m_src_n_samples = n_samples[src_sample];
test_case.m_dst_target = targets[dst_target];
test_case.m_dst_n_samples = n_samples[dst_sample];
if (test_case.m_src_n_samples == test_case.m_dst_n_samples)
{
test_case.m_expected_result = GL_NO_ERROR;
}
else
{
test_case.m_expected_result = GL_INVALID_OPERATION;
}
m_test_cases.push_back(test_case);
}
}
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult SamplesMismatchTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name = Utils::prepareMultisampleTex(m_context, test_case.m_dst_target, test_case.m_dst_n_samples);
m_src_tex_name = Utils::prepareMultisampleTex(m_context, test_case.m_src_target, test_case.m_src_n_samples);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
GLenum expected_result = test_case.m_expected_result;
if (test_case.m_dst_n_samples > 0 && test_case.m_src_n_samples > 0)
{
/* Implementations are allowed to use more samples than requested, so we need
* to verify the actual sample counts allocated by the hardware and adjust
* the expected result if they are different from what we requested.
*/
GLint num_src_samples;
GLint num_dst_samples;
gl.bindTexture(test_case.m_dst_target, m_dst_tex_name);
gl.getTexLevelParameteriv(test_case.m_dst_target, 0, GL_TEXTURE_SAMPLES, &num_dst_samples);
gl.bindTexture(test_case.m_src_target, m_src_tex_name);
gl.getTexLevelParameteriv(test_case.m_src_target, 0, GL_TEXTURE_SAMPLES, &num_src_samples);
if (num_dst_samples != test_case.m_dst_n_samples || num_src_samples != test_case.m_src_n_samples)
{
/* The hardware allocated a different number of samples, check if this affects the expected
* result of the test. This can happen if we requested different sample counts but the
* hardware ended up allocating the same or viceversa.
*/
if (test_case.m_dst_n_samples != test_case.m_src_n_samples && num_dst_samples == num_src_samples)
{
expected_result = GL_NO_ERROR;
}
else if (test_case.m_dst_n_samples == test_case.m_src_n_samples && num_dst_samples != num_src_samples)
{
expected_result = GL_INVALID_OPERATION;
}
}
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_src_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_dst_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, 1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (expected_result == error);
/* Free resources */
clean();
/* Set result */
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Source target: " << glu::getTextureTargetStr(test_case.m_src_target)
<< " samples: " << test_case.m_src_n_samples
<< ", destination target: " << glu::getTextureTargetStr(test_case.m_dst_target)
<< " samples: " << test_case.m_dst_n_samples << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void SamplesMismatchTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures . Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
}
/* IncompatibleFormatsCompressionTest */
/** Constructor
*
* @param context Text context
**/
IncompatibleFormatsCompressionTest::IncompatibleFormatsCompressionTest(deqp::Context& context)
: TestCase(context, "incompatible_formats_compression", "Test verifies if INVALID_OPERATION is generated when "
"textures provided to CopyImageSubData are incompatible, "
"one of formats is compressed")
, m_dst_tex_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
/* Skip 1D targets, not supported */
if ((GL_TEXTURE_1D == tex_target) || (GL_TEXTURE_1D_ARRAY == tex_target) || (GL_TEXTURE_3D == tex_target) ||
(GL_TEXTURE_RECTANGLE == tex_target) || (GL_RENDERBUFFER == tex_target) || (GL_TEXTURE_CUBE_MAP_ARRAY == tex_target))
{
continue;
}
/* Skip multisampled and rectangle targets */
if (true == Utils::isTargetMultisampled(tex_target))
{
continue;
}
/* Compressed 128bit vs RGBA32UI */
{
testCase test_case = {
tex_target, GL_RGBA32UI, GL_RGBA_INTEGER, GL_UNSIGNED_INT, GL_COMPRESSED_RG_RGTC2,
GL_RG, GL_UNSIGNED_BYTE, GL_NO_ERROR
};
m_test_cases.push_back(test_case);
}
/* Compressed 128bit vs RGBA16UI */
{
testCase test_case = {
tex_target, GL_RGBA16UI, GL_RGBA_INTEGER, GL_UNSIGNED_SHORT, GL_COMPRESSED_RG_RGTC2,
GL_RG, GL_UNSIGNED_BYTE, GL_INVALID_OPERATION
};
m_test_cases.push_back(test_case);
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult IncompatibleFormatsCompressionTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
GLuint temp = 0;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, test_case.m_dst_internal_format,
test_case.m_dst_format, test_case.m_dst_type, temp);
m_src_tex_name = Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, test_case.m_src_internal_format,
test_case.m_src_format, test_case.m_src_type, temp);
/* Make textures complete */
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_dst_tex_name, 0 /* base */, 0 /* max */);
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_src_tex_name, 0 /* base */, 0 /* max */);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_tex_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_tex_target, 0 /* dstLevel */, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, 4 /* srcWidth */, 4 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Remove resources */
clean();
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Texture target: " << glu::getTextureTargetStr(test_case.m_tex_target)
<< ". Source format: " << glu::getInternalFormatParameterStr(test_case.m_src_internal_format)
<< ". Destination format: " << glu::getInternalFormatParameterStr(test_case.m_dst_internal_format)
<< tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void IncompatibleFormatsCompressionTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
}
/* InvalidObjectTest */
/** Constructor
*
* @param context Text context
**/
InvalidObjectTest::InvalidObjectTest(deqp::Context& context)
: TestCase(
context, "invalid_object",
"Test verifies if INVALID_VALUE is generated when object & target provided to CopyImageSubData do not match")
, m_dst_name(0)
, m_src_name(0)
, m_test_case_index(0)
{
static glw::GLenum arg_types[] = { GL_TEXTURE_2D, GL_RENDERBUFFER };
static const GLuint n_arg_types = sizeof(arg_types) / sizeof(arg_types[0]);
for (GLuint dst = 0; dst < n_arg_types; dst++)
{
for (GLuint src = 0; src < n_arg_types; src++)
{
for (GLuint dst_valid = 0; dst_valid < 2; dst_valid++)
{
for (GLuint src_valid = 0; src_valid < 2; src_valid++)
{
glw::GLenum expected_error = GL_INVALID_VALUE;
if (!!src_valid && !!dst_valid)
{
expected_error = GL_NO_ERROR;
}
const testCase test_case = { arg_types[dst], !!dst_valid, arg_types[src], !!src_valid,
expected_error };
m_test_cases.push_back(test_case);
}
}
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult InvalidObjectTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
GLuint temp = 0;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare objects */
if (GL_RENDERBUFFER == test_case.m_dst_target)
{
m_dst_name = Utils::prepareRenderBuffer(m_context, GL_RGBA8);
}
else
{
m_dst_name =
Utils::prepareTex16x16x6(m_context, test_case.m_dst_target, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, temp);
/* Make textures complete */
Utils::makeTextureComplete(m_context, test_case.m_dst_target, m_dst_name, 0 /* base */, 0 /* max */);
}
if (GL_RENDERBUFFER == test_case.m_src_target)
{
m_src_name = Utils::prepareRenderBuffer(m_context, GL_RGBA8);
}
else
{
m_src_name =
Utils::prepareTex16x16x6(m_context, test_case.m_src_target, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, temp);
/* Make texture complete */
Utils::makeTextureComplete(m_context, test_case.m_src_target, m_src_name, 0 /* base */, 0 /* max */);
}
/* If an object is invalid, free it before use to make it invalid */
if (!test_case.m_dst_valid)
{
Utils::deleteTexture(m_context, test_case.m_dst_target, m_dst_name);
}
if (!test_case.m_src_valid)
{
Utils::deleteTexture(m_context, test_case.m_src_target, m_src_name);
}
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_name, test_case.m_src_target, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */, 0 /* srcZ */,
m_dst_name, test_case.m_dst_target, 0 /* dstLevel */, 0 /* dstX */, 0 /* dstY */, 0 /* dstZ */,
1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Remove resources */
clean();
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Destination target: " << glu::getTextureTargetStr(test_case.m_dst_target)
<< ". Destination valid: " << (test_case.m_src_valid ? "true" : "false")
<< ". Source target: " << glu::getTextureTargetStr(test_case.m_dst_target)
<< ". Source valid: " << (test_case.m_dst_valid ? "true" : "false") << "." << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void InvalidObjectTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
const testCase& test_case = m_test_cases[m_test_case_index];
/* Clean textures or renderbuffers. Errors ignored */
if (test_case.m_dst_valid)
{
if (GL_RENDERBUFFER == test_case.m_dst_target)
{
gl.deleteRenderbuffers(1, &m_dst_name);
}
else
{
gl.deleteTextures(1, &m_dst_name);
}
}
if (test_case.m_src_valid)
{
if (GL_RENDERBUFFER == test_case.m_src_target)
{
gl.deleteRenderbuffers(1, &m_src_name);
}
else
{
gl.deleteTextures(1, &m_src_name);
}
}
m_dst_name = 0;
m_src_name = 0;
}
/* NonExistentMipMapTest */
/** Constructor
*
* @param context Text context
**/
NonExistentMipMapTest::NonExistentMipMapTest(deqp::Context& context)
: TestCase(context, "non_existent_mipmap", "Test verifies if INVALID_VALUE is generated when CopyImageSubData is "
"executed for mipmap that does not exist")
, m_dst_tex_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
testCase test_case = { tex_target, 0, 0, GL_NO_ERROR };
if (GL_RENDERBUFFER == tex_target)
{
continue;
}
m_test_cases.push_back(test_case);
/* Rest of cases is invalid */
test_case.m_expected_result = GL_INVALID_VALUE;
test_case.m_dst_level = 1;
test_case.m_src_level = 0;
m_test_cases.push_back(test_case);
test_case.m_dst_level = 0;
test_case.m_src_level = 1;
m_test_cases.push_back(test_case);
test_case.m_dst_level = 1;
test_case.m_src_level = 1;
m_test_cases.push_back(test_case);
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult NonExistentMipMapTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
GLuint temp = 0;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name =
Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, temp);
m_src_tex_name =
Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, temp);
/* Make textures complete */
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_dst_tex_name, 0 /* base */, 0 /* max */);
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_src_tex_name, 0 /* base */, 0 /* max */);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_tex_target, test_case.m_src_level, 0 /* srcX */, 0 /* srcY */,
0 /* srcZ */, m_dst_tex_name, test_case.m_tex_target, test_case.m_dst_level, 0 /* dstX */,
0 /* dstY */, 0 /* dstZ */, 1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Free resources */
clean();
/* Set result */
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Texture target: " << glu::getTextureTargetStr(test_case.m_tex_target)
<< ", source level: " << test_case.m_src_level << ", destination level: " << test_case.m_dst_level
<< tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void NonExistentMipMapTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
}
/* ExceedingBoundariesTest */
const glw::GLuint ExceedingBoundariesTest::m_region_depth = 4;
const glw::GLuint ExceedingBoundariesTest::m_region_height = 4;
const glw::GLuint ExceedingBoundariesTest::m_region_width = 4;
/** Constructor
*
* @param context Text context
**/
ExceedingBoundariesTest::ExceedingBoundariesTest(deqp::Context& context)
: TestCase(context, "exceeding_boundaries", "Test verifies if INVALID_VALUE is generated when CopyImageSubData is "
"executed for regions exceeding image boundaries")
, m_dst_tex_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
/* 16x16x6 are values used by prepareTex16x16x6 */
static const GLuint invalid_x = 16 - (m_region_width / 2);
static const GLuint invalid_y = 16 - (m_region_height / 2);
static const GLuint invalid_z = 6 - (m_region_depth / 2);
static const GLuint x_vals[] = { 0, invalid_x };
static const GLuint y_vals[] = { 0, invalid_y };
static const GLuint z_vals[] = { 0, invalid_z };
static const GLuint n_x_vals = sizeof(x_vals) / sizeof(x_vals[0]);
static const GLuint n_y_vals = sizeof(y_vals) / sizeof(y_vals[0]);
static const GLuint n_z_vals = sizeof(z_vals) / sizeof(z_vals[0]);
for (GLuint target = 0; target < s_n_valid_targets; ++target)
{
const GLenum tex_target = s_valid_targets[target];
GLuint height = m_region_height;
if (GL_TEXTURE_BUFFER == tex_target)
{
continue;
}
if ((GL_TEXTURE_1D == tex_target) || (GL_TEXTURE_1D_ARRAY == tex_target))
{
height = 1;
}
for (GLuint x = 0; x < n_x_vals; ++x)
{
for (GLuint y = 0; y < n_y_vals; ++y)
{
for (GLuint z = 0; z < n_z_vals; ++z)
{
const GLuint x_val = x_vals[x];
const GLuint y_val = y_vals[y];
const GLuint z_val = z_vals[z];
const GLenum res = ((0 == x_val) && (0 == y_val) && (0 == z_val)) ? GL_NO_ERROR : GL_INVALID_VALUE;
GLuint depth = 1;
if (0 != z_val)
{
if ((GL_TEXTURE_2D_ARRAY != tex_target) || (GL_TEXTURE_2D_MULTISAMPLE_ARRAY != tex_target) ||
(GL_TEXTURE_3D != tex_target) || (GL_TEXTURE_CUBE_MAP_ARRAY != tex_target))
{
/* Skip z != 0 for 2d textures */
continue;
}
else
{
/* Set depth so as to exceed boundary */
depth = m_region_depth;
}
}
testCase src_test_case = { tex_target, depth, height, x_val, y_val, z_val, 0, 0, 0, res };
testCase dst_test_case = { tex_target, depth, height, 0, 0, 0, x_val, y_val, z_val, res };
m_test_cases.push_back(src_test_case);
m_test_cases.push_back(dst_test_case);
}
}
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult ExceedingBoundariesTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
GLuint temp = 0;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name =
Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, temp);
m_src_tex_name =
Utils::prepareTex16x16x6(m_context, test_case.m_tex_target, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, temp);
/* Make textures complete */
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_dst_tex_name, 0 /* base */, 0 /* max */);
Utils::makeTextureComplete(m_context, test_case.m_tex_target, m_src_tex_name, 0 /* base */, 0 /* max */);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, test_case.m_tex_target, 0 /* level */, test_case.m_src_x /* srcX */,
test_case.m_src_y /* srcY */, test_case.m_src_z /* srcZ */, m_dst_tex_name,
test_case.m_tex_target, 0 /* level */, test_case.m_dst_x /* dstX */,
test_case.m_dst_y /* dstY */, test_case.m_dst_z /* dstZ */, m_region_width /* srcWidth */,
test_case.m_height /* srcHeight */, test_case.m_depth /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Free resources */
clean();
/* Set result */
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error)
<< ". Texture target: " << glu::getTextureTargetStr(test_case.m_tex_target) << ", source: ["
<< test_case.m_src_x << ", " << test_case.m_src_y << ", " << test_case.m_src_z << "], destination: ["
<< test_case.m_src_x << ", " << test_case.m_src_y << ", " << test_case.m_src_z
<< "], depth: " << test_case.m_depth << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void ExceedingBoundariesTest::clean()
{
const testCase& test_case = m_test_cases[m_test_case_index];
/* Clean textures and buffers. Errors ignored */
Utils::deleteTexture(m_context, test_case.m_tex_target, m_dst_tex_name);
Utils::deleteTexture(m_context, test_case.m_tex_target, m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
}
/* InvalidAlignmentTest */
/** Constructor
*
* @param context Text context
**/
InvalidAlignmentTest::InvalidAlignmentTest(deqp::Context& context)
: TestCase(context, "invalid_alignment", "Test verifies if INVALID_VALUE is generated when CopyImageSubData is "
"executed for regions with invalid alignment")
, m_dst_tex_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
/* 16x16x6 are values used by prepareTex16x16x6 */
static const GLuint invalid_h = 2;
static const GLuint invalid_w = 2;
static const GLuint invalid_x = 2;
static const GLuint invalid_y = 2;
static const GLuint valid_h = 4;
static const GLuint valid_w = 4;
static const GLuint h_vals[] = { valid_h, invalid_h };
static const GLuint w_vals[] = { valid_w, invalid_w };
static const GLuint x_vals[] = { 0, invalid_x };
static const GLuint y_vals[] = { 0, invalid_y };
static const GLuint n_h_vals = sizeof(h_vals) / sizeof(h_vals[0]);
static const GLuint n_w_vals = sizeof(w_vals) / sizeof(w_vals[0]);
static const GLuint n_x_vals = sizeof(x_vals) / sizeof(x_vals[0]);
static const GLuint n_y_vals = sizeof(y_vals) / sizeof(y_vals[0]);
for (GLuint x = 0; x < n_x_vals; ++x)
{
for (GLuint y = 0; y < n_y_vals; ++y)
{
for (GLuint h = 0; h < n_h_vals; ++h)
{
for (GLuint w = 0; w < n_w_vals; ++w)
{
const GLuint h_val = h_vals[h];
const GLuint w_val = w_vals[w];
const GLuint x_val = x_vals[x];
const GLuint y_val = y_vals[y];
const GLenum res = ((valid_h == h_val) && (valid_w == w_val) && (0 == x_val) && (0 == y_val)) ?
GL_NO_ERROR :
GL_INVALID_VALUE;
testCase dst_test_case = { h_val, w_val, 0, 0, x_val, y_val, res };
testCase src_test_case = { h_val, w_val, x_val, y_val, 0, 0, res };
m_test_cases.push_back(dst_test_case);
m_test_cases.push_back(src_test_case);
}
}
}
}
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult InvalidAlignmentTest::iterate()
{
GLenum error = GL_NO_ERROR;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
bool result = false;
GLuint temp = 0;
const testCase& test_case = m_test_cases[m_test_case_index];
try
{
/* Prepare textures */
m_dst_tex_name =
Utils::prepareTex16x16x6(m_context, GL_TEXTURE_2D, GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_BYTE, temp);
m_src_tex_name =
Utils::prepareTex16x16x6(m_context, GL_TEXTURE_2D, GL_COMPRESSED_RG_RGTC2, GL_RG, GL_UNSIGNED_BYTE, temp);
/* Make textures complete */
Utils::makeTextureComplete(m_context, GL_TEXTURE_2D, m_dst_tex_name, 0 /* base */, 0 /* max */);
Utils::makeTextureComplete(m_context, GL_TEXTURE_2D, m_src_tex_name, 0 /* base */, 0 /* max */);
}
catch (tcu::Exception& exc)
{
clean();
throw exc;
}
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, GL_TEXTURE_2D, 0 /* level */, test_case.m_src_x /* srcX */,
test_case.m_src_y /* srcY */, 0 /* srcZ */, m_dst_tex_name, GL_TEXTURE_2D, 0 /* level */,
test_case.m_dst_x /* dstX */, test_case.m_dst_y /* dstY */, 0 /* dstZ */,
test_case.m_width /* srcWidth */, test_case.m_height /* srcHeight */, 1 /* srcDepth */);
/* Verify generated error */
error = gl.getError();
result = (test_case.m_expected_result == error);
/* Free resources */
clean();
/* Set result */
if (true == result)
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
m_test_case_index += 1;
/* Are there any test cases left */
if (m_test_cases.size() > m_test_case_index)
{
it_result = tcu::TestNode::CONTINUE;
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected result: " << glu::getErrorStr(test_case.m_expected_result)
<< " got: " << glu::getErrorStr(error) << ". source: [" << test_case.m_src_x << ", " << test_case.m_src_y
<< "], destination: [" << test_case.m_src_x << ", " << test_case.m_src_y << "], size: " << test_case.m_width
<< " x " << test_case.m_height << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Done */
return it_result;
}
/** Cleans resources
*
**/
void InvalidAlignmentTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
}
/** Constructor
*
* @param context Text context
**/
IntegerTexTest::IntegerTexTest(deqp::Context& context)
: TestCase(
context, "integer_tex",
"Test verifies if INVALID_OPERATION is generated when texture provided to CopySubImageData is incomplete")
, m_dst_buf_name(0)
, m_dst_tex_name(0)
, m_src_buf_name(0)
, m_src_tex_name(0)
, m_test_case_index(0)
{
}
/** Execute test
*
* @return CONTINUE as long there are more test case, STOP otherwise
**/
tcu::TestNode::IterateResult IntegerTexTest::iterate()
{
testCase testCases[] = { { GL_R32I, GL_INT }, { GL_R32UI, GL_UNSIGNED_INT } };
const unsigned int width = 16;
const unsigned int height = 16;
const Functions& gl = m_context.getRenderContext().getFunctions();
tcu::TestNode::IterateResult it_result = tcu::TestNode::STOP;
const testCase& test_case = testCases[m_test_case_index];
std::vector<int> data_buf(width * height, 1);
m_dst_tex_name = createTexture(width, height, test_case.m_internal_format, test_case.m_type, &data_buf[0],
GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR);
std::fill(data_buf.begin(), data_buf.end(), 2);
m_src_tex_name = createTexture(width, height, test_case.m_internal_format, test_case.m_type, &data_buf[0],
GL_NEAREST_MIPMAP_LINEAR, GL_LINEAR);
/* Execute CopyImageSubData */
gl.copyImageSubData(m_src_tex_name, GL_TEXTURE_2D, 0 /* srcLevel */, 0 /* srcX */, 0 /* srcY */, 0 /* srcZ */,
m_dst_tex_name, GL_TEXTURE_2D, 0 /* dstLevel */, 0 /* dstX */, 0 /* dstY */, 0 /* dstZ */,
1 /* srcWidth */, 1 /* srcHeight */, 1 /* srcDepth */);
/* Check generated error */
GLenum error = gl.getError();
if (error == GL_NO_ERROR)
{
/* Verify result */
std::fill(data_buf.begin(), data_buf.end(), 3);
gl.bindTexture(GL_TEXTURE_2D, m_dst_tex_name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.getTexImage(GL_TEXTURE_2D, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, &data_buf[0]);
GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage");
if ((data_buf[0] == 2) && (std::count(data_buf.begin(), data_buf.end(), 1) == (width * height - 1)))
{
m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Pass");
/* Increase index */
++m_test_case_index;
/* Are there any test cases left */
if (DE_LENGTH_OF_ARRAY(testCases) > m_test_case_index)
it_result = tcu::TestNode::CONTINUE;
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Image data is not valid." << tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
}
else
{
m_context.getTestContext().getLog()
<< tcu::TestLog::Message << "Failure. Expected no error, got: " << glu::getErrorStr(error)
<< ". Texture internal format: " << glu::getTextureFormatStr(test_case.m_internal_format)
<< tcu::TestLog::EndMessage;
m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Fail");
}
/* Remove resources */
clean();
/* Done */
return it_result;
}
/** Create texture
*
**/
unsigned int IntegerTexTest::createTexture(int width, int height, GLint internalFormat, GLuint type, const void* data,
int minFilter, int magFilter)
{
const Functions& gl = m_context.getRenderContext().getFunctions();
GLuint tex_name;
gl.genTextures(1, &tex_name);
GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures");
gl.bindTexture(GL_TEXTURE_2D, tex_name);
GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");
gl.texImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, GL_RED_INTEGER, type, data);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexImage2D");
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");
gl.bindTexture(GL_TEXTURE_2D, 0);
return tex_name;
}
/** Cleans resources
*
**/
void IntegerTexTest::clean()
{
const Functions& gl = m_context.getRenderContext().getFunctions();
/* Clean textures and buffers. Errors ignored */
gl.deleteTextures(1, &m_dst_tex_name);
gl.deleteTextures(1, &m_src_tex_name);
m_dst_tex_name = 0;
m_src_tex_name = 0;
if (0 != m_dst_buf_name)
{
gl.deleteBuffers(1, &m_dst_buf_name);
m_dst_buf_name = 0;
}
if (0 != m_src_buf_name)
{
gl.deleteBuffers(1, &m_src_buf_name);
m_src_buf_name = 0;
}
}
} /* namespace CopyImage */
CopyImageTests::CopyImageTests(deqp::Context& context) : TestCaseGroup(context, "copy_image", "")
{
}
CopyImageTests::~CopyImageTests(void)
{
}
void CopyImageTests::init()
{
addChild(new CopyImage::FunctionalTest(m_context));
addChild(new CopyImage::IncompleteTexTest(m_context));
addChild(new CopyImage::InvalidObjectTest(m_context));
addChild(new CopyImage::SmokeTest(m_context));
addChild(new CopyImage::InvalidTargetTest(m_context));
addChild(new CopyImage::TargetMismatchTest(m_context));
addChild(new CopyImage::IncompatibleFormatsTest(m_context));
addChild(new CopyImage::SamplesMismatchTest(m_context));
addChild(new CopyImage::IncompatibleFormatsCompressionTest(m_context));
addChild(new CopyImage::NonExistentMipMapTest(m_context));
addChild(new CopyImage::ExceedingBoundariesTest(m_context));
addChild(new CopyImage::InvalidAlignmentTest(m_context));
addChild(new CopyImage::IntegerTexTest(m_context));
}
} /* namespace gl4cts */