xref: /aosp_15_r20/external/deqp/framework/common/tcuTextureUtil.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program Tester Core
 * ----------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * 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
 * \brief Texture utilities.
 *//*--------------------------------------------------------------------*/

#include "tcuTextureUtil.hpp"
#include "tcuVectorUtil.hpp"
#include "deRandom.hpp"
#include "deMath.h"
#include "deMemory.h"

#include <limits>

namespace tcu
{

float sRGBChannelToLinear(float cs)
{
    if (cs <= 0.04045)
        return cs / 12.92f;
    else
        return deFloatPow((cs + 0.055f) / 1.055f, 2.4f);
}

static const uint32_t s_srgb8Lut[256] = {
#include "tcuSRGB8Lut.inl"
};

static inline float sRGB8ChannelToLinear(uint32_t cs)
{
    DE_ASSERT(cs < 256);

    // \note This triggers UB, but in practice it doesn't cause any problems
    return ((const float *)s_srgb8Lut)[cs];
}

float linearChannelToSRGB(float cl)
{
    if (cl <= 0.0f)
        return 0.0f;
    else if (cl < 0.0031308f)
        return 12.92f * cl;
    else if (cl < 1.0f)
        return 1.055f * deFloatPow(cl, 0.41666f) - 0.055f;
    else
        return 1.0f;
}

//! Convert sRGB to linear colorspace
Vec4 sRGBToLinear(const Vec4 &cs)
{
    return Vec4(sRGBChannelToLinear(cs[0]), sRGBChannelToLinear(cs[1]), sRGBChannelToLinear(cs[2]), cs[3]);
}

Vec4 sRGB8ToLinear(const UVec4 &cs)
{
    return Vec4(sRGB8ChannelToLinear(cs[0]), sRGB8ChannelToLinear(cs[1]), sRGB8ChannelToLinear(cs[2]), 1.0f);
}

Vec4 sRGBA8ToLinear(const UVec4 &cs)
{
    return Vec4(sRGB8ChannelToLinear(cs[0]), sRGB8ChannelToLinear(cs[1]), sRGB8ChannelToLinear(cs[2]),
                (float)cs[3] / 255.0f);
}

//! Convert from linear to sRGB colorspace
Vec4 linearToSRGB(const Vec4 &cl)
{
    return Vec4(linearChannelToSRGB(cl[0]), linearChannelToSRGB(cl[1]), linearChannelToSRGB(cl[2]), cl[3]);
}

bool isSRGB(TextureFormat format)
{
    // make sure to update this if type table is updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 22);

    return format.order == TextureFormat::sR || format.order == TextureFormat::sRG ||
           format.order == TextureFormat::sRGB || format.order == TextureFormat::sRGBA ||
           format.order == TextureFormat::sBGR || format.order == TextureFormat::sBGRA;
}

tcu::Vec4 linearToSRGBIfNeeded(const TextureFormat &format, const tcu::Vec4 &color)
{
    return isSRGB(format) ? linearToSRGB(color) : color;
}

bool isCombinedDepthStencilType(TextureFormat::ChannelType type)
{
    // make sure to update this if type table is updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 48);

    return type == TextureFormat::UNSIGNED_INT_16_8_8 || type == TextureFormat::UNSIGNED_INT_24_8 ||
           type == TextureFormat::UNSIGNED_INT_24_8_REV || type == TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV;
}

bool hasStencilComponent(TextureFormat::ChannelOrder order)
{
    DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 22);

    switch (order)
    {
    case TextureFormat::S:
    case TextureFormat::DS:
        return true;

    default:
        return false;
    }
}

bool hasDepthComponent(TextureFormat::ChannelOrder order)
{
    DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 22);

    switch (order)
    {
    case TextureFormat::D:
    case TextureFormat::DS:
        return true;

    default:
        return false;
    }
}

//! Get texture channel class for format - how the values are stored (not how they are sampled)
TextureChannelClass getTextureChannelClass(TextureFormat::ChannelType channelType)
{
    // make sure this table is updated if format table is updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 48);

    switch (channelType)
    {
    case TextureFormat::SNORM_INT8:
        return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
    case TextureFormat::SNORM_INT16:
        return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
    case TextureFormat::SNORM_INT32:
        return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
    case TextureFormat::UNORM_INT8:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_INT16:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_INT24:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_INT32:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_BYTE_44:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_SHORT_565:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_SHORT_555:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_SHORT_4444:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_SHORT_5551:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_SHORT_1555:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNSIGNED_BYTE_44:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_SHORT_565:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_SHORT_4444:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_SHORT_5551:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNORM_INT_101010:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::SNORM_INT_1010102_REV:
        return TEXTURECHANNELCLASS_SIGNED_FIXED_POINT;
    case TextureFormat::UNORM_INT_1010102_REV:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::SIGNED_INT_1010102_REV:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    case TextureFormat::UNSIGNED_INT_1010102_REV:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
        return TEXTURECHANNELCLASS_FLOATING_POINT;
    case TextureFormat::UNSIGNED_INT_999_E5_REV:
        return TEXTURECHANNELCLASS_FLOATING_POINT;
    case TextureFormat::UNSIGNED_INT_16_8_8:
        return TEXTURECHANNELCLASS_LAST; //!< packed unorm16-x8-uint8
    case TextureFormat::UNSIGNED_INT_24_8:
        return TEXTURECHANNELCLASS_LAST; //!< packed unorm24-uint8
    case TextureFormat::UNSIGNED_INT_24_8_REV:
        return TEXTURECHANNELCLASS_LAST; //!< packed unorm24-uint8
    case TextureFormat::SIGNED_INT8:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    case TextureFormat::SIGNED_INT16:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    case TextureFormat::SIGNED_INT32:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    case TextureFormat::SIGNED_INT64:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    case TextureFormat::UNSIGNED_INT8:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_INT16:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_INT24:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_INT32:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::UNSIGNED_INT64:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::HALF_FLOAT:
        return TEXTURECHANNELCLASS_FLOATING_POINT;
    case TextureFormat::FLOAT:
        return TEXTURECHANNELCLASS_FLOATING_POINT;
    case TextureFormat::FLOAT64:
        return TEXTURECHANNELCLASS_FLOATING_POINT;
    case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
        return TEXTURECHANNELCLASS_LAST; //!< packed float32-pad24-uint8
    case TextureFormat::UNORM_SHORT_10:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::UNORM_SHORT_12:
        return TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    case TextureFormat::USCALED_INT8:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::USCALED_INT16:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::SSCALED_INT8:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    case TextureFormat::SSCALED_INT16:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    case TextureFormat::USCALED_INT_1010102_REV:
        return TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
    case TextureFormat::SSCALED_INT_1010102_REV:
        return TEXTURECHANNELCLASS_SIGNED_INTEGER;
    default:
        DE_FATAL("Unknown channel type");
        return TEXTURECHANNELCLASS_LAST;
    }
}

bool isAccessValid(TextureFormat format, TextureAccessType type)
{
    DE_ASSERT(isValid(format));

    if (format.order == TextureFormat::DS)
    {
        // It is never allowed to access combined depth-stencil format with getPixel().
        // Instead either getPixDepth() or getPixStencil(), or effective depth- or stencil-
        // access must be used.
        return false;
    }
    else if (format.order == TextureFormat::D)
        return type == TEXTUREACCESSTYPE_FLOAT;
    else if (format.order == TextureFormat::S)
        return type == TEXTUREACCESSTYPE_UNSIGNED_INT;
    else
    {
        // A few packed color formats have access type restrictions
        if (format.type == TextureFormat::UNSIGNED_INT_11F_11F_10F_REV ||
            format.type == TextureFormat::UNSIGNED_INT_999_E5_REV)
            return type == TEXTUREACCESSTYPE_FLOAT;
        else
            return true;
    }
}

/*--------------------------------------------------------------------*//*!
 * \brief Get access to subregion of pixel buffer
 * \param access    Parent access object
 * \param x            X offset
 * \param y            Y offset
 * \param z            Z offset
 * \param width        Width
 * \param height    Height
 * \param depth        Depth
 * \return Access object that targets given subregion of parent access object
 *//*--------------------------------------------------------------------*/
ConstPixelBufferAccess getSubregion(const ConstPixelBufferAccess &access, int x, int y, int z, int width, int height,
                                    int depth)
{
    DE_ASSERT(de::inBounds(x, 0, access.getWidth()));
    DE_ASSERT(de::inRange(x + width, x + 1, access.getWidth()));

    DE_ASSERT(de::inBounds(y, 0, access.getHeight()));
    DE_ASSERT(de::inRange(y + height, y + 1, access.getHeight()));

    DE_ASSERT(de::inBounds(z, 0, access.getDepth()));
    if (depth != -1) // Handles case of VK_REMAINING_ARRAY_LAYERS
        DE_ASSERT(de::inRange(z + depth, z + 1, access.getDepth()));

    return ConstPixelBufferAccess(access.getFormat(), tcu::IVec3(width, height, depth), access.getPitch(),
                                  (const uint8_t *)access.getDataPtr() + access.getPixelPitch() * x +
                                      access.getRowPitch() * y + access.getSlicePitch() * z);
}

/*--------------------------------------------------------------------*//*!
 * \brief Get access to subregion of pixel buffer
 * \param access    Parent access object
 * \param x            X offset
 * \param y            Y offset
 * \param z            Z offset
 * \param width        Width
 * \param height    Height
 * \param depth        Depth
 * \return Access object that targets given subregion of parent access object
 *//*--------------------------------------------------------------------*/
PixelBufferAccess getSubregion(const PixelBufferAccess &access, int x, int y, int z, int width, int height, int depth)
{
    DE_ASSERT(de::inBounds(x, 0, access.getWidth()));
    DE_ASSERT(de::inRange(x + width, x + 1, access.getWidth()));

    DE_ASSERT(de::inBounds(y, 0, access.getHeight()));
    DE_ASSERT(de::inRange(y + height, y + 1, access.getHeight()));

    DE_ASSERT(de::inBounds(z, 0, access.getDepth()));
    if (depth != -1) // Handles case of VK_REMAINING_ARRAY_LAYERS
        DE_ASSERT(de::inRange(z + depth, z + 1, access.getDepth()));

    return PixelBufferAccess(access.getFormat(), tcu::IVec3(width, height, depth), access.getPitch(),
                             (uint8_t *)access.getDataPtr() + access.getPixelPitch() * x + access.getRowPitch() * y +
                                 access.getSlicePitch() * z);
}

/*--------------------------------------------------------------------*//*!
 * \brief Get access to subregion of pixel buffer
 * \param access    Parent access object
 * \param x            X offset
 * \param y            Y offset
 * \param width        Width
 * \param height    Height
 * \return Access object that targets given subregion of parent access object
 *//*--------------------------------------------------------------------*/
PixelBufferAccess getSubregion(const PixelBufferAccess &access, int x, int y, int width, int height)
{
    return getSubregion(access, x, y, 0, width, height, 1);
}

/*--------------------------------------------------------------------*//*!
 * \brief Get access to subregion of pixel buffer
 * \param access    Parent access object
 * \param x            X offset
 * \param y            Y offset
 * \param width        Width
 * \param height    Height
 * \return Access object that targets given subregion of parent access object
 *//*--------------------------------------------------------------------*/
ConstPixelBufferAccess getSubregion(const ConstPixelBufferAccess &access, int x, int y, int width, int height)
{
    return getSubregion(access, x, y, 0, width, height, 1);
}

/*--------------------------------------------------------------------*//*!
 * \brief Flip rows in Y direction
 * \param access Access object
 * \return Modified access object where Y coordinates are reversed
 *//*--------------------------------------------------------------------*/
PixelBufferAccess flipYAccess(const PixelBufferAccess &access)
{
    const int rowPitch     = access.getRowPitch();
    const int offsetToLast = rowPitch * (access.getHeight() - 1);
    const tcu::IVec3 pitch(access.getPixelPitch(), -rowPitch, access.getSlicePitch());

    return PixelBufferAccess(access.getFormat(), access.getSize(), pitch,
                             (uint8_t *)access.getDataPtr() + offsetToLast);
}

/*--------------------------------------------------------------------*//*!
 * \brief Flip rows in Y direction
 * \param access Access object
 * \return Modified access object where Y coordinates are reversed
 *//*--------------------------------------------------------------------*/
ConstPixelBufferAccess flipYAccess(const ConstPixelBufferAccess &access)
{
    const int rowPitch     = access.getRowPitch();
    const int offsetToLast = rowPitch * (access.getHeight() - 1);
    const tcu::IVec3 pitch(access.getPixelPitch(), -rowPitch, access.getSlicePitch());

    return ConstPixelBufferAccess(access.getFormat(), access.getSize(), pitch,
                                  (uint8_t *)access.getDataPtr() + offsetToLast);
}

static Vec2 getFloatChannelValueRange(TextureFormat::ChannelType channelType)
{
    // make sure this table is updated if format table is updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 48);

    float cMin = 0.0f;
    float cMax = 0.0f;

    switch (channelType)
    {
    // Signed normalized formats.
    case TextureFormat::SNORM_INT8:
    case TextureFormat::SNORM_INT16:
    case TextureFormat::SNORM_INT32:
    case TextureFormat::SNORM_INT_1010102_REV:
        cMin = -1.0f;
        cMax = 1.0f;
        break;

    // Unsigned normalized formats.
    case TextureFormat::UNORM_INT8:
    case TextureFormat::UNORM_INT16:
    case TextureFormat::UNORM_INT24:
    case TextureFormat::UNORM_INT32:
    case TextureFormat::UNORM_BYTE_44:
    case TextureFormat::UNORM_SHORT_565:
    case TextureFormat::UNORM_SHORT_555:
    case TextureFormat::UNORM_SHORT_4444:
    case TextureFormat::UNORM_SHORT_5551:
    case TextureFormat::UNORM_SHORT_1555:
    case TextureFormat::UNORM_INT_101010:
    case TextureFormat::UNORM_INT_1010102_REV:
    case TextureFormat::UNORM_SHORT_10:
    case TextureFormat::UNORM_SHORT_12:
        cMin = 0.0f;
        cMax = 1.0f;
        break;

    // Misc formats.
    case TextureFormat::SIGNED_INT8:
        cMin = -128.0f;
        cMax = 127.0f;
        break;
    case TextureFormat::SIGNED_INT16:
        cMin = -32768.0f;
        cMax = 32767.0f;
        break;
    case TextureFormat::SIGNED_INT32:
        cMin = -2147483520.0f;
        cMax = 2147483520.0f;
        break; // Maximum exactly representable 31-bit integer: (2^24 - 1) * 2^7
    case TextureFormat::UNSIGNED_INT8:
        cMin = 0.0f;
        cMax = 255.0f;
        break;
    case TextureFormat::UNSIGNED_INT16:
        cMin = 0.0f;
        cMax = 65535.0f;
        break;
    case TextureFormat::UNSIGNED_INT24:
        cMin = 0.0f;
        cMax = 16777215.0f;
        break;
    case TextureFormat::UNSIGNED_INT32:
        cMin = 0.0f;
        cMax = 4294967040.f;
        break; // Maximum exactly representable 32-bit integer: (2^24 - 1) * 2^8
    case TextureFormat::HALF_FLOAT:
        cMin = -1e3f;
        cMax = 1e3f;
        break;
    case TextureFormat::FLOAT:
        cMin = -1e5f;
        cMax = 1e5f;
        break;
    case TextureFormat::FLOAT64:
        cMin = -1e5f;
        cMax = 1e5f;
        break;
    case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
        cMin = 0.0f;
        cMax = 1e4f;
        break;
    case TextureFormat::UNSIGNED_INT_999_E5_REV:
        cMin = 0.0f;
        cMax = 0.5e5f;
        break;
    case TextureFormat::UNSIGNED_BYTE_44:
        cMin = 0.0f;
        cMax = 15.f;
        break;
    case TextureFormat::UNSIGNED_SHORT_4444:
        cMin = 0.0f;
        cMax = 15.f;
        break;
    case TextureFormat::USCALED_INT8:
        cMin = 0.0f;
        cMax = 255.0f;
        break;
    case TextureFormat::USCALED_INT16:
        cMin = 0.0f;
        cMax = 65535.0f;
        break;
    case TextureFormat::SSCALED_INT8:
        cMin = -128.0f;
        cMax = 127.0f;
        break;
    case TextureFormat::SSCALED_INT16:
        cMin = -32768.0f;
        cMax = 32767.0f;
        break;
    case TextureFormat::USCALED_INT_1010102_REV:
        cMin = 0.0f;
        cMax = 1023.0f;
        break;
    case TextureFormat::SSCALED_INT_1010102_REV:
        cMin = -512.0f;
        cMax = 511.0f;
        break;

    default:
        DE_ASSERT(false);
    }

    return Vec2(cMin, cMax);
}

/*--------------------------------------------------------------------*//*!
 * \brief Get standard parameters for testing texture format
 *
 * Returns TextureFormatInfo that describes good parameters for exercising
 * given TextureFormat. Parameters include value ranges per channel and
 * suitable lookup scaling and bias in order to reduce result back to
 * 0..1 range.
 *//*--------------------------------------------------------------------*/
TextureFormatInfo getTextureFormatInfo(const TextureFormat &format)
{
    // Special cases.
    if (format.type == TextureFormat::UNSIGNED_INT_1010102_REV)
        return TextureFormatInfo(Vec4(0.0f, 0.0f, 0.0f, 0.0f), Vec4(1023.0f, 1023.0f, 1023.0f, 3.0f),
                                 Vec4(1.0f / 1023.f, 1.0f / 1023.0f, 1.0f / 1023.0f, 1.0f / 3.0f),
                                 Vec4(0.0f, 0.0f, 0.0f, 0.0f));
    if (format.type == TextureFormat::SIGNED_INT_1010102_REV)
        return TextureFormatInfo(Vec4(-512.0f, -512.0f, -512.0f, -2.0f), Vec4(511.0f, 511.0f, 511.0f, 1.0f),
                                 Vec4(1.0f / 1023.f, 1.0f / 1023.0f, 1.0f / 1023.0f, 1.0f / 3.0f),
                                 Vec4(0.5f, 0.5f, 0.5f, 0.5f));
    else if (format.order == TextureFormat::D || format.order == TextureFormat::DS)
        return TextureFormatInfo(Vec4(0.0f, 0.0f, 0.0f, 0.0f), Vec4(1.0f, 1.0f, 1.0f, 255.0f),
                                 Vec4(1.0f, 1.0f, 1.0f, 1.0f),
                                 Vec4(0.0f, 0.0f, 0.0f, 0.0f)); // Depth / stencil formats.
    else if (format == TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_SHORT_5551))
        return TextureFormatInfo(Vec4(0.0f, 0.0f, 0.0f, 0.5f), Vec4(1.0f, 1.0f, 1.0f, 1.5f),
                                 Vec4(1.0f, 1.0f, 1.0f, 1.0f), Vec4(0.0f, 0.0f, 0.0f, 0.0f));
    else if (format.type == TextureFormat::UNSIGNED_SHORT_5551)
        return TextureFormatInfo(Vec4(0.0f, 0.0f, 0.0f, 0.0f), Vec4(31.0f, 31.0f, 31.0f, 1.0f),
                                 Vec4(1.0f / 31.f, 1.0f / 31.0f, 1.0f / 31.0f, 1.0f), Vec4(0.0f, 0.0f, 0.0f, 0.0f));
    else if (format.type == TextureFormat::UNSIGNED_SHORT_565)
        return TextureFormatInfo(Vec4(0.0f, 0.0f, 0.0f, 0.0f), Vec4(31.0f, 63.0f, 31.0f, 0.0f),
                                 Vec4(1.0f / 31.f, 1.0f / 63.0f, 1.0f / 31.0f, 1.0f), Vec4(0.0f, 0.0f, 0.0f, 0.0f));

    const Vec2 cRange                  = getFloatChannelValueRange(format.type);
    const TextureSwizzle::Channel *map = getChannelReadSwizzle(format.order).components;
    const BVec4 chnMask = BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true);
    const float scale   = 1.0f / (cRange[1] - cRange[0]);
    const float bias    = -cRange[0] * scale;

    return TextureFormatInfo(select(cRange[0], 0.0f, chnMask), select(cRange[1], 0.0f, chnMask),
                             select(scale, 1.0f, chnMask), select(bias, 0.0f, chnMask));
}

IVec4 getFormatMinIntValue(const TextureFormat &format)
{
    DE_ASSERT(getTextureChannelClass(format.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER);

    switch (format.type)
    {
    case TextureFormat::SIGNED_INT8:
        return IVec4(std::numeric_limits<int8_t>::min());
    case TextureFormat::SIGNED_INT16:
        return IVec4(std::numeric_limits<int16_t>::min());
    case TextureFormat::SIGNED_INT32:
        return IVec4(std::numeric_limits<int32_t>::min());

    default:
        DE_FATAL("Invalid channel type");
        return IVec4(0);
    }
}

IVec4 getFormatMaxIntValue(const TextureFormat &format)
{
    DE_ASSERT(getTextureChannelClass(format.type) == TEXTURECHANNELCLASS_SIGNED_INTEGER);

    if (format == TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT_1010102_REV) ||
        format == TextureFormat(TextureFormat::BGRA, TextureFormat::SSCALED_INT_1010102_REV) ||
        format == TextureFormat(TextureFormat::RGBA, TextureFormat::SSCALED_INT_1010102_REV) ||
        format == TextureFormat(TextureFormat::BGRA, TextureFormat::SIGNED_INT_1010102_REV))
        return IVec4(511, 511, 511, 1);

    switch (format.type)
    {
    case TextureFormat::SIGNED_INT8:
        return IVec4(std::numeric_limits<int8_t>::max());
    case TextureFormat::SIGNED_INT16:
        return IVec4(std::numeric_limits<int16_t>::max());
    case TextureFormat::SIGNED_INT32:
        return IVec4(std::numeric_limits<int32_t>::max());

    case TextureFormat::SSCALED_INT8:
        return IVec4(std::numeric_limits<int8_t>::max());
    case TextureFormat::SSCALED_INT16:
        return IVec4(std::numeric_limits<int16_t>::max());

    default:
        DE_FATAL("Invalid channel type");
        return IVec4(0);
    }
}

UVec4 getFormatMaxUintValue(const TextureFormat &format)
{
    DE_ASSERT(getTextureChannelClass(format.type) == TEXTURECHANNELCLASS_UNSIGNED_INTEGER);

    if (format == TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT_1010102_REV) ||
        format == TextureFormat(TextureFormat::RGBA, TextureFormat::USCALED_INT_1010102_REV) ||
        format == TextureFormat(TextureFormat::BGRA, TextureFormat::USCALED_INT_1010102_REV) ||
        format == TextureFormat(TextureFormat::BGRA, TextureFormat::UNSIGNED_INT_1010102_REV))
        return UVec4(1023u, 1023u, 1023u, 3u);

    switch (format.type)
    {
    case TextureFormat::UNSIGNED_INT8:
        return UVec4(std::numeric_limits<uint8_t>::max());
    case TextureFormat::UNSIGNED_INT16:
        return UVec4(std::numeric_limits<uint16_t>::max());
    case TextureFormat::UNSIGNED_INT24:
        return UVec4(0xffffffu);
    case TextureFormat::UNSIGNED_INT32:
        return UVec4(std::numeric_limits<uint32_t>::max());

    case TextureFormat::USCALED_INT8:
        return UVec4(std::numeric_limits<uint8_t>::max());
    case TextureFormat::USCALED_INT16:
        return UVec4(std::numeric_limits<uint16_t>::max());

    default:
        DE_FATAL("Invalid channel type");
        return UVec4(0);
    }
}

static IVec4 getChannelBitDepth(TextureFormat::ChannelType channelType)
{
    // make sure this table is updated if format table is updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 48);

    switch (channelType)
    {
    case TextureFormat::SNORM_INT8:
        return IVec4(8);
    case TextureFormat::SNORM_INT16:
        return IVec4(16);
    case TextureFormat::SNORM_INT32:
        return IVec4(32);
    case TextureFormat::UNORM_INT8:
        return IVec4(8);
    case TextureFormat::UNORM_INT16:
        return IVec4(16);
    case TextureFormat::UNORM_INT24:
        return IVec4(24);
    case TextureFormat::UNORM_INT32:
        return IVec4(32);
    case TextureFormat::UNORM_BYTE_44:
        return IVec4(4, 4, 0, 0);
    case TextureFormat::UNORM_SHORT_565:
        return IVec4(5, 6, 5, 0);
    case TextureFormat::UNORM_SHORT_4444:
        return IVec4(4);
    case TextureFormat::UNORM_SHORT_555:
        return IVec4(5, 5, 5, 0);
    case TextureFormat::UNORM_SHORT_5551:
        return IVec4(5, 5, 5, 1);
    case TextureFormat::UNORM_SHORT_1555:
        return IVec4(1, 5, 5, 5);
    case TextureFormat::UNSIGNED_BYTE_44:
        return IVec4(4, 4, 0, 0);
    case TextureFormat::UNSIGNED_SHORT_565:
        return IVec4(5, 6, 5, 0);
    case TextureFormat::UNSIGNED_SHORT_4444:
        return IVec4(4);
    case TextureFormat::UNSIGNED_SHORT_5551:
        return IVec4(5, 5, 5, 1);
    case TextureFormat::UNORM_INT_101010:
        return IVec4(10, 10, 10, 0);
    case TextureFormat::SNORM_INT_1010102_REV:
        return IVec4(10, 10, 10, 2);
    case TextureFormat::UNORM_INT_1010102_REV:
        return IVec4(10, 10, 10, 2);
    case TextureFormat::SIGNED_INT8:
        return IVec4(8);
    case TextureFormat::SIGNED_INT16:
        return IVec4(16);
    case TextureFormat::SIGNED_INT32:
        return IVec4(32);
    case TextureFormat::SIGNED_INT64:
        return IVec4(64);
    case TextureFormat::UNSIGNED_INT8:
        return IVec4(8);
    case TextureFormat::UNSIGNED_INT16:
        return IVec4(16);
    case TextureFormat::UNSIGNED_INT24:
        return IVec4(24);
    case TextureFormat::UNSIGNED_INT32:
        return IVec4(32);
    case TextureFormat::UNSIGNED_INT64:
        return IVec4(64);
    case TextureFormat::SIGNED_INT_1010102_REV:
        return IVec4(10, 10, 10, 2);
    case TextureFormat::UNSIGNED_INT_1010102_REV:
        return IVec4(10, 10, 10, 2);
    case TextureFormat::UNSIGNED_INT_16_8_8:
        return IVec4(16, 8, 0, 0);
    case TextureFormat::UNSIGNED_INT_24_8:
        return IVec4(24, 8, 0, 0);
    case TextureFormat::UNSIGNED_INT_24_8_REV:
        return IVec4(24, 8, 0, 0);
    case TextureFormat::HALF_FLOAT:
        return IVec4(16);
    case TextureFormat::FLOAT:
        return IVec4(32);
    case TextureFormat::FLOAT64:
        return IVec4(64);
    case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
        return IVec4(11, 11, 10, 0);
    case TextureFormat::UNSIGNED_INT_999_E5_REV:
        return IVec4(9, 9, 9, 0);
    case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
        return IVec4(32, 8, 0, 0);
    case TextureFormat::UNORM_SHORT_10:
        return IVec4(10);
    case TextureFormat::UNORM_SHORT_12:
        return IVec4(12);
    case TextureFormat::USCALED_INT8:
        return IVec4(8);
    case TextureFormat::USCALED_INT16:
        return IVec4(16);
    case TextureFormat::SSCALED_INT8:
        return IVec4(8);
    case TextureFormat::SSCALED_INT16:
        return IVec4(16);
    case TextureFormat::USCALED_INT_1010102_REV:
        return IVec4(10, 10, 10, 2);
    case TextureFormat::SSCALED_INT_1010102_REV:
        return IVec4(10, 10, 10, 2);
    default:
        DE_ASSERT(false);
        return IVec4(0);
    }
}

IVec4 getTextureFormatBitDepth(const TextureFormat &format)
{
    const IVec4 chnBits                = getChannelBitDepth(format.type);
    const TextureSwizzle::Channel *map = getChannelReadSwizzle(format.order).components;
    const BVec4 chnMask = BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true);
    const IVec4 chnSwz  = IVec4((chnMask[0]) ? ((int)map[0]) : (0), (chnMask[1]) ? ((int)map[1]) : (0),
                               (chnMask[2]) ? ((int)map[2]) : (0), (chnMask[3]) ? ((int)map[3]) : (0));

    return select(chnBits.swizzle(chnSwz.x(), chnSwz.y(), chnSwz.z(), chnSwz.w()), IVec4(0), chnMask);
}

static IVec4 getChannelMantissaBitDepth(TextureFormat::ChannelType channelType)
{
    // make sure this table is updated if format table is updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 48);

    switch (channelType)
    {
    case TextureFormat::SNORM_INT8:
    case TextureFormat::SNORM_INT16:
    case TextureFormat::SNORM_INT32:
    case TextureFormat::UNORM_INT8:
    case TextureFormat::UNORM_INT16:
    case TextureFormat::UNORM_INT24:
    case TextureFormat::UNORM_INT32:
    case TextureFormat::UNORM_BYTE_44:
    case TextureFormat::UNORM_SHORT_565:
    case TextureFormat::UNORM_SHORT_4444:
    case TextureFormat::UNORM_SHORT_555:
    case TextureFormat::UNORM_SHORT_5551:
    case TextureFormat::UNORM_SHORT_1555:
    case TextureFormat::UNSIGNED_BYTE_44:
    case TextureFormat::UNSIGNED_SHORT_565:
    case TextureFormat::UNSIGNED_SHORT_4444:
    case TextureFormat::UNSIGNED_SHORT_5551:
    case TextureFormat::UNORM_INT_101010:
    case TextureFormat::SNORM_INT_1010102_REV:
    case TextureFormat::UNORM_INT_1010102_REV:
    case TextureFormat::SIGNED_INT8:
    case TextureFormat::SIGNED_INT16:
    case TextureFormat::SIGNED_INT32:
    case TextureFormat::UNSIGNED_INT8:
    case TextureFormat::UNSIGNED_INT16:
    case TextureFormat::UNSIGNED_INT24:
    case TextureFormat::UNSIGNED_INT32:
    case TextureFormat::SIGNED_INT_1010102_REV:
    case TextureFormat::UNSIGNED_INT_1010102_REV:
    case TextureFormat::UNSIGNED_INT_16_8_8:
    case TextureFormat::UNSIGNED_INT_24_8:
    case TextureFormat::UNSIGNED_INT_24_8_REV:
    case TextureFormat::UNSIGNED_INT_999_E5_REV:
    case TextureFormat::UNORM_SHORT_10:
    case TextureFormat::UNORM_SHORT_12:
    case TextureFormat::USCALED_INT8:
    case TextureFormat::USCALED_INT16:
    case TextureFormat::SSCALED_INT8:
    case TextureFormat::SSCALED_INT16:
    case TextureFormat::USCALED_INT_1010102_REV:
    case TextureFormat::SSCALED_INT_1010102_REV:
        return getChannelBitDepth(channelType);

    case TextureFormat::HALF_FLOAT:
        return IVec4(10);
    case TextureFormat::FLOAT:
        return IVec4(23);
    case TextureFormat::FLOAT64:
        return IVec4(52);
    case TextureFormat::UNSIGNED_INT_11F_11F_10F_REV:
        return IVec4(6, 6, 5, 0);
    case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
        return IVec4(23, 8, 0, 0);
    default:
        DE_ASSERT(false);
        return IVec4(0);
    }
}

IVec4 getTextureFormatMantissaBitDepth(const TextureFormat &format)
{
    const IVec4 chnBits                = getChannelMantissaBitDepth(format.type);
    const TextureSwizzle::Channel *map = getChannelReadSwizzle(format.order).components;
    const BVec4 chnMask = BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                                deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true);
    const IVec4 chnSwz  = IVec4((chnMask[0]) ? ((int)map[0]) : (0), (chnMask[1]) ? ((int)map[1]) : (0),
                               (chnMask[2]) ? ((int)map[2]) : (0), (chnMask[3]) ? ((int)map[3]) : (0));

    return select(chnBits.swizzle(chnSwz.x(), chnSwz.y(), chnSwz.z(), chnSwz.w()), IVec4(0), chnMask);
}

BVec4 getTextureFormatChannelMask(const TextureFormat &format)
{
    const TextureSwizzle::Channel *const map = getChannelReadSwizzle(format.order).components;
    return BVec4(deInRange32(map[0], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                 deInRange32(map[1], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                 deInRange32(map[2], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true,
                 deInRange32(map[3], TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true);
}

static inline float linearInterpolate(float t, float minVal, float maxVal)
{
    return minVal + (maxVal - minVal) * t;
}

static inline Vec4 linearInterpolate(float t, const Vec4 &a, const Vec4 &b)
{
    return a + (b - a) * t;
}

enum
{
    CLEAR_OPTIMIZE_THRESHOLD      = 128,
    CLEAR_OPTIMIZE_MAX_PIXEL_SIZE = 8
};

inline void fillRow(const PixelBufferAccess &dst, int y, int z, int pixelSize, const uint8_t *pixel)
{
    DE_ASSERT(dst.getPixelPitch() == pixelSize); // only tightly packed

    uint8_t *dstPtr = (uint8_t *)dst.getPixelPtr(0, y, z);
    int width       = dst.getWidth();

    if (pixelSize == 8 && deIsAlignedPtr(dstPtr, pixelSize))
    {
        uint64_t val;
        memcpy(&val, pixel, sizeof(val));

        for (int i = 0; i < width; i++)
            ((uint64_t *)dstPtr)[i] = val;
    }
    else if (pixelSize == 4 && deIsAlignedPtr(dstPtr, pixelSize))
    {
        uint32_t val;
        memcpy(&val, pixel, sizeof(val));

        for (int i = 0; i < width; i++)
            ((uint32_t *)dstPtr)[i] = val;
    }
    else
    {
        for (int i = 0; i < width; i++)
            for (int j = 0; j < pixelSize; j++)
                dstPtr[i * pixelSize + j] = pixel[j];
    }
}

void clear(const PixelBufferAccess &access, const Vec4 &color)
{
    const int pixelSize               = access.getFormat().getPixelSize();
    const int pixelPitch              = access.getPixelPitch();
    const bool rowPixelsTightlyPacked = (pixelSize == pixelPitch);

    if (access.getWidth() * access.getHeight() * access.getDepth() >= CLEAR_OPTIMIZE_THRESHOLD &&
        pixelSize < CLEAR_OPTIMIZE_MAX_PIXEL_SIZE && rowPixelsTightlyPacked)
    {
        // Convert to destination format.
        union
        {
            uint8_t u8[CLEAR_OPTIMIZE_MAX_PIXEL_SIZE];
            uint64_t u64; // Forces 64-bit alignment.
        } pixel;
        DE_STATIC_ASSERT(sizeof(pixel) == CLEAR_OPTIMIZE_MAX_PIXEL_SIZE);
        PixelBufferAccess(access.getFormat(), 1, 1, 1, 0, 0, &pixel.u8[0]).setPixel(color, 0, 0);

        for (int z = 0; z < access.getDepth(); z++)
            for (int y = 0; y < access.getHeight(); y++)
                fillRow(access, y, z, pixelSize, &pixel.u8[0]);
    }
    else
    {
        for (int z = 0; z < access.getDepth(); z++)
            for (int y = 0; y < access.getHeight(); y++)
                for (int x = 0; x < access.getWidth(); x++)
                    access.setPixel(color, x, y, z);
    }
}

void clear(const PixelBufferAccess &access, const IVec4 &color)
{
    const int pixelSize               = access.getFormat().getPixelSize();
    const int pixelPitch              = access.getPixelPitch();
    const bool rowPixelsTightlyPacked = (pixelSize == pixelPitch);

    if (access.getWidth() * access.getHeight() * access.getDepth() >= CLEAR_OPTIMIZE_THRESHOLD &&
        pixelSize < CLEAR_OPTIMIZE_MAX_PIXEL_SIZE && rowPixelsTightlyPacked)
    {
        // Convert to destination format.
        union
        {
            uint8_t u8[CLEAR_OPTIMIZE_MAX_PIXEL_SIZE];
            uint64_t u64; // Forces 64-bit alignment.
        } pixel;
        DE_STATIC_ASSERT(sizeof(pixel) == CLEAR_OPTIMIZE_MAX_PIXEL_SIZE);
        PixelBufferAccess(access.getFormat(), 1, 1, 1, 0, 0, &pixel.u8[0]).setPixel(color, 0, 0);

        for (int z = 0; z < access.getDepth(); z++)
            for (int y = 0; y < access.getHeight(); y++)
                fillRow(access, y, z, pixelSize, &pixel.u8[0]);
    }
    else
    {
        for (int z = 0; z < access.getDepth(); z++)
            for (int y = 0; y < access.getHeight(); y++)
                for (int x = 0; x < access.getWidth(); x++)
                    access.setPixel(color, x, y, z);
    }
}

void clear(const PixelBufferAccess &access, const UVec4 &color)
{
    clear(access, color.cast<int32_t>());
}

void clearDepth(const PixelBufferAccess &access, float depth)
{
    DE_ASSERT(access.getFormat().order == TextureFormat::DS || access.getFormat().order == TextureFormat::D);

    clear(getEffectiveDepthStencilAccess(access, Sampler::MODE_DEPTH), tcu::Vec4(depth, 0.0f, 0.0f, 0.0f));
}

void clearStencil(const PixelBufferAccess &access, int stencil)
{
    DE_ASSERT(access.getFormat().order == TextureFormat::DS || access.getFormat().order == TextureFormat::S);

    clear(getEffectiveDepthStencilAccess(access, Sampler::MODE_STENCIL), tcu::UVec4(stencil, 0u, 0u, 0u));
}

enum GradientStyle
{
    GRADIENT_STYLE_OLD     = 0,
    GRADIENT_STYLE_NEW     = 1,
    GRADIENT_STYLE_PYRAMID = 2
};

static void fillWithComponentGradients1D(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal,
                                         GradientStyle)
{
    DE_ASSERT(access.getHeight() == 1);
    for (int x = 0; x < access.getWidth(); x++)
    {
        float s = ((float)x + 0.5f) / (float)access.getWidth();

        float r = linearInterpolate(s, minVal.x(), maxVal.x());
        float g = linearInterpolate(s, minVal.y(), maxVal.y());
        float b = linearInterpolate(s, minVal.z(), maxVal.z());
        float a = linearInterpolate(s, minVal.w(), maxVal.w());

        access.setPixel(tcu::Vec4(r, g, b, a), x, 0);
    }
}

static void fillWithComponentGradients2D(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal,
                                         GradientStyle style)
{
    if (style == GRADIENT_STYLE_PYRAMID)
    {
        int xedge = deFloorFloatToInt32(float(access.getWidth()) * 0.6f);
        int yedge = deFloorFloatToInt32(float(access.getHeight()) * 0.6f);

        for (int y = 0; y < access.getHeight(); y++)
        {
            for (int x = 0; x < access.getWidth(); x++)
            {
                float s     = ((float)x + 0.5f) / (float)access.getWidth();
                float t     = ((float)y + 0.5f) / (float)access.getHeight();
                float coefR = 0.0f;
                float coefG = 0.0f;
                float coefB = 0.0f;
                float coefA = 0.0f;

                coefR = (x < xedge) ? s * 0.4f : (1 - s) * 0.6f;
                coefG = (x < xedge) ? s * 0.4f : (1 - s) * 0.6f;
                coefB = (x < xedge) ? (1.0f - s) * 0.4f : s * 0.6f - 0.2f;
                coefA = (x < xedge) ? (1.0f - s) * 0.4f : s * 0.6f - 0.2f;

                coefR += (y < yedge) ? t * 0.4f : (1 - t) * 0.6f;
                coefG += (y < yedge) ? (1.0f - t) * 0.4f : t * 0.6f - 0.2f;
                coefB += (y < yedge) ? t * 0.4f : (1 - t) * 0.6f;
                coefA += (y < yedge) ? (1.0f - t) * 0.4f : t * 0.6f - 0.2f;

                float r = linearInterpolate(coefR, minVal.x(), maxVal.x());
                float g = linearInterpolate(coefG, minVal.y(), maxVal.y());
                float b = linearInterpolate(coefB, minVal.z(), maxVal.z());
                float a = linearInterpolate(coefA, minVal.w(), maxVal.w());

                access.setPixel(tcu::Vec4(r, g, b, a), x, y);
            }
        }
    }
    else
    {
        for (int y = 0; y < access.getHeight(); y++)
        {
            for (int x = 0; x < access.getWidth(); x++)
            {
                float s = ((float)x + 0.5f) / (float)access.getWidth();
                float t = ((float)y + 0.5f) / (float)access.getHeight();

                float r = linearInterpolate((s + t) * 0.5f, minVal.x(), maxVal.x());
                float g = linearInterpolate((s + (1.0f - t)) * 0.5f, minVal.y(), maxVal.y());
                float b = linearInterpolate(((1.0f - s) + t) * 0.5f, minVal.z(), maxVal.z());
                float a = linearInterpolate(((1.0f - s) + (1.0f - t)) * 0.5f, minVal.w(), maxVal.w());

                access.setPixel(tcu::Vec4(r, g, b, a), x, y);
            }
        }
    }
}

static void fillWithComponentGradients3D(const PixelBufferAccess &dst, const Vec4 &minVal, const Vec4 &maxVal,
                                         GradientStyle style)
{
    for (int z = 0; z < dst.getDepth(); z++)
    {
        for (int y = 0; y < dst.getHeight(); y++)
        {
            for (int x = 0; x < dst.getWidth(); x++)
            {
                float s = ((float)x + 0.5f) / (float)dst.getWidth();
                float t = ((float)y + 0.5f) / (float)dst.getHeight();
                float p = ((float)z + 0.5f) / (float)dst.getDepth();

                float r, g, b, a;

                if (style == GRADIENT_STYLE_NEW)
                {
                    // R, G, B and A all depend on every coordinate.
                    r = linearInterpolate((s + t + p) / 3.0f, minVal.x(), maxVal.x());
                    g = linearInterpolate((s + (1.0f - (t + p) * 0.5f) * 2.0f) / 3.0f, minVal.y(), maxVal.y());
                    b = linearInterpolate(((1.0f - (s + t) * 0.5f) * 2.0f + p) / 3.0f, minVal.z(), maxVal.z());
                    a = linearInterpolate(1.0f - (s + t + p) / 3.0f, minVal.w(), maxVal.w());
                }
                else // GRADIENT_STYLE_OLD
                {
                    // Each of R, G and B only depend on X, Y and Z, respectively.
                    r = linearInterpolate(s, minVal.x(), maxVal.x());
                    g = linearInterpolate(t, minVal.y(), maxVal.y());
                    b = linearInterpolate(p, minVal.z(), maxVal.z());
                    a = linearInterpolate(1.0f - (s + t + p) / 3.0f, minVal.w(), maxVal.w());
                }

                dst.setPixel(tcu::Vec4(r, g, b, a), x, y, z);
            }
        }
    }
}

void fillWithComponentGradientsStyled(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal,
                                      GradientStyle style)
{
    if (isCombinedDepthStencilType(access.getFormat().type))
    {
        const bool hasDepth =
            access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::D;
        const bool hasStencil =
            access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::S;

        DE_ASSERT(hasDepth || hasStencil);

        // For combined formats, treat D and S as separate channels
        if (hasDepth)
            fillWithComponentGradientsStyled(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_DEPTH), minVal,
                                             maxVal, style);
        if (hasStencil)
            fillWithComponentGradientsStyled(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_STENCIL),
                                             minVal.swizzle(3, 2, 1, 0), maxVal.swizzle(3, 2, 1, 0), style);
    }
    else
    {
        if (access.getHeight() == 1 && access.getDepth() == 1)
            fillWithComponentGradients1D(access, minVal, maxVal, style);
        else if (access.getDepth() == 1)
            fillWithComponentGradients2D(access, minVal, maxVal, style);
        else
            fillWithComponentGradients3D(access, minVal, maxVal, style);
    }
}

void fillWithComponentGradients(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal)
{
    fillWithComponentGradientsStyled(access, minVal, maxVal, GRADIENT_STYLE_OLD);
}

void fillWithComponentGradients2(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal)
{
    fillWithComponentGradientsStyled(access, minVal, maxVal, GRADIENT_STYLE_NEW);
}

void fillWithComponentGradients3(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal)
{
    fillWithComponentGradientsStyled(access, minVal, maxVal, GRADIENT_STYLE_PYRAMID);
}

static void fillWithGrid1D(const PixelBufferAccess &access, int cellSize, const Vec4 &colorA, const Vec4 &colorB)
{
    for (int x = 0; x < access.getWidth(); x++)
    {
        int mx = (x / cellSize) % 2;

        if (mx)
            access.setPixel(colorB, x, 0);
        else
            access.setPixel(colorA, x, 0);
    }
}

static void fillWithGrid2D(const PixelBufferAccess &access, int cellSize, const Vec4 &colorA, const Vec4 &colorB)
{
    for (int y = 0; y < access.getHeight(); y++)
    {
        for (int x = 0; x < access.getWidth(); x++)
        {
            int mx = (x / cellSize) % 2;
            int my = (y / cellSize) % 2;

            if (mx ^ my)
                access.setPixel(colorB, x, y);
            else
                access.setPixel(colorA, x, y);
        }
    }
}

static void fillWithGrid3D(const PixelBufferAccess &access, int cellSize, const Vec4 &colorA, const Vec4 &colorB)
{
    for (int z = 0; z < access.getDepth(); z++)
    {
        for (int y = 0; y < access.getHeight(); y++)
        {
            for (int x = 0; x < access.getWidth(); x++)
            {
                int mx = (x / cellSize) % 2;
                int my = (y / cellSize) % 2;
                int mz = (z / cellSize) % 2;

                if (mx ^ my ^ mz)
                    access.setPixel(colorB, x, y, z);
                else
                    access.setPixel(colorA, x, y, z);
            }
        }
    }
}

void fillWithGrid(const PixelBufferAccess &access, int cellSize, const Vec4 &colorA, const Vec4 &colorB)
{
    if (isCombinedDepthStencilType(access.getFormat().type))
    {
        const bool hasDepth =
            access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::D;
        const bool hasStencil =
            access.getFormat().order == tcu::TextureFormat::DS || access.getFormat().order == tcu::TextureFormat::S;

        DE_ASSERT(hasDepth || hasStencil);

        // For combined formats, treat D and S as separate channels
        if (hasDepth)
            fillWithGrid(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_DEPTH), cellSize, colorA, colorB);
        if (hasStencil)
            fillWithGrid(getEffectiveDepthStencilAccess(access, tcu::Sampler::MODE_STENCIL), cellSize,
                         colorA.swizzle(3, 2, 1, 0), colorB.swizzle(3, 2, 1, 0));
    }
    else
    {
        if (access.getHeight() == 1 && access.getDepth() == 1)
            fillWithGrid1D(access, cellSize, colorA, colorB);
        else if (access.getDepth() == 1)
            fillWithGrid2D(access, cellSize, colorA, colorB);
        else
            fillWithGrid3D(access, cellSize, colorA, colorB);
    }
}

void fillWithRepeatableGradient(const PixelBufferAccess &access, const Vec4 &colorA, const Vec4 &colorB)
{
    for (int y = 0; y < access.getHeight(); y++)
    {
        for (int x = 0; x < access.getWidth(); x++)
        {
            float s = ((float)x + 0.5f) / (float)access.getWidth();
            float t = ((float)y + 0.5f) / (float)access.getHeight();

            float a = s > 0.5f ? (2.0f - 2.0f * s) : 2.0f * s;
            float b = t > 0.5f ? (2.0f - 2.0f * t) : 2.0f * t;

            float p = deFloatClamp(deFloatSqrt(a * a + b * b), 0.0f, 1.0f);
            access.setPixel(linearInterpolate(p, colorA, colorB), x, y);
        }
    }
}

void fillWithRGBAQuads(const PixelBufferAccess &dst)
{
    TCU_CHECK_INTERNAL(dst.getDepth() == 1);
    int width  = dst.getWidth();
    int height = dst.getHeight();
    int left   = width / 2;
    int top    = height / 2;

    clear(getSubregion(dst, 0, 0, 0, left, top, 1), Vec4(1.0f, 0.0f, 0.0f, 1.0f));
    clear(getSubregion(dst, left, 0, 0, width - left, top, 1), Vec4(0.0f, 1.0f, 0.0f, 1.0f));
    clear(getSubregion(dst, 0, top, 0, left, height - top, 1), Vec4(0.0f, 0.0f, 1.0f, 0.0f));
    clear(getSubregion(dst, left, top, 0, width - left, height - top, 1), Vec4(0.5f, 0.5f, 0.5f, 1.0f));
}

// \todo [2012-11-13 pyry] There is much better metaballs code in CL SIR value generators.
void fillWithMetaballs(const PixelBufferAccess &dst, int numBalls, uint32_t seed)
{
    TCU_CHECK_INTERNAL(dst.getDepth() == 1);
    std::vector<Vec2> points(numBalls);
    de::Random rnd(seed);

    for (int i = 0; i < numBalls; i++)
    {
        float x   = rnd.getFloat();
        float y   = rnd.getFloat();
        points[i] = (Vec2(x, y));
    }

    for (int y = 0; y < dst.getHeight(); y++)
        for (int x = 0; x < dst.getWidth(); x++)
        {
            Vec2 p((float)x / (float)dst.getWidth(), (float)y / (float)dst.getHeight());

            float sum = 0.0f;
            for (std::vector<Vec2>::const_iterator i = points.begin(); i != points.end(); i++)
            {
                Vec2 d  = p - *i;
                float f = 0.01f / (d.x() * d.x() + d.y() * d.y());

                sum += f;
            }

            dst.setPixel(Vec4(sum), x, y);
        }
}

void copy(const PixelBufferAccess &dst, const ConstPixelBufferAccess &src, const bool clearUnused)
{
    DE_ASSERT(src.getSize() == dst.getSize());

    const int width  = dst.getWidth();
    const int height = dst.getHeight();
    const int depth  = dst.getDepth();

    const int srcPixelSize      = src.getFormat().getPixelSize();
    const int dstPixelSize      = dst.getFormat().getPixelSize();
    const int srcPixelPitch     = src.getPixelPitch();
    const int dstPixelPitch     = dst.getPixelPitch();
    const bool srcTightlyPacked = (srcPixelSize == srcPixelPitch);
    const bool dstTightlyPacked = (dstPixelSize == dstPixelPitch);

    const bool srcHasDepth =
        (src.getFormat().order == tcu::TextureFormat::DS || src.getFormat().order == tcu::TextureFormat::D);
    const bool srcHasStencil =
        (src.getFormat().order == tcu::TextureFormat::DS || src.getFormat().order == tcu::TextureFormat::S);
    const bool dstHasDepth =
        (dst.getFormat().order == tcu::TextureFormat::DS || dst.getFormat().order == tcu::TextureFormat::D);
    const bool dstHasStencil =
        (dst.getFormat().order == tcu::TextureFormat::DS || dst.getFormat().order == tcu::TextureFormat::S);

    if (src.getFormat() == dst.getFormat() && srcTightlyPacked && dstTightlyPacked)
    {
        // Fast-path for matching formats.
        for (int z = 0; z < depth; z++)
            for (int y = 0; y < height; y++)
                deMemcpy(dst.getPixelPtr(0, y, z), src.getPixelPtr(0, y, z), srcPixelSize * width);
    }
    else if (src.getFormat() == dst.getFormat())
    {
        // Bit-exact copy for matching formats.
        for (int z = 0; z < depth; z++)
            for (int y = 0; y < height; y++)
                for (int x = 0; x < width; x++)
                    deMemcpy(dst.getPixelPtr(x, y, z), src.getPixelPtr(x, y, z), srcPixelSize);
    }
    else if (srcHasDepth || srcHasStencil || dstHasDepth || dstHasStencil)
    {
        DE_ASSERT((srcHasDepth && dstHasDepth) ||
                  (srcHasStencil && dstHasStencil)); // must have at least one common channel

        if (dstHasDepth && srcHasDepth)
        {
            for (int z = 0; z < depth; z++)
                for (int y = 0; y < height; y++)
                    for (int x = 0; x < width; x++)
                        dst.setPixDepth(src.getPixDepth(x, y, z), x, y, z);
        }
        else if (dstHasDepth && !srcHasDepth && clearUnused)
        {
            // consistency with color copies
            tcu::clearDepth(dst, 0.0f);
        }

        if (dstHasStencil && srcHasStencil)
        {
            for (int z = 0; z < depth; z++)
                for (int y = 0; y < height; y++)
                    for (int x = 0; x < width; x++)
                        dst.setPixStencil(src.getPixStencil(x, y, z), x, y, z);
        }
        else if (dstHasStencil && !srcHasStencil && clearUnused)
        {
            // consistency with color copies
            tcu::clearStencil(dst, 0u);
        }
    }
    else
    {
        TextureChannelClass srcClass = getTextureChannelClass(src.getFormat().type);
        TextureChannelClass dstClass = getTextureChannelClass(dst.getFormat().type);
        bool srcIsInt =
            srcClass == TEXTURECHANNELCLASS_SIGNED_INTEGER || srcClass == TEXTURECHANNELCLASS_UNSIGNED_INTEGER;
        bool dstIsInt =
            dstClass == TEXTURECHANNELCLASS_SIGNED_INTEGER || dstClass == TEXTURECHANNELCLASS_UNSIGNED_INTEGER;

        if (srcIsInt && dstIsInt)
        {
            for (int z = 0; z < depth; z++)
                for (int y = 0; y < height; y++)
                    for (int x = 0; x < width; x++)
                        dst.setPixel(src.getPixelInt(x, y, z), x, y, z);
        }
        else
        {
            for (int z = 0; z < depth; z++)
                for (int y = 0; y < height; y++)
                    for (int x = 0; x < width; x++)
                        dst.setPixel(src.getPixel(x, y, z), x, y, z);
        }
    }
}

void scale(const PixelBufferAccess &dst, const ConstPixelBufferAccess &src, Sampler::FilterMode filter)
{
    DE_ASSERT(filter == Sampler::NEAREST || filter == Sampler::LINEAR);

    Sampler sampler(Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, Sampler::CLAMP_TO_EDGE, filter, filter, 0.0f,
                    false);

    float sX = (float)src.getWidth() / (float)dst.getWidth();
    float sY = (float)src.getHeight() / (float)dst.getHeight();
    float sZ = (float)src.getDepth() / (float)dst.getDepth();

    if (dst.getDepth() == 1 && src.getDepth() == 1)
    {
        for (int y = 0; y < dst.getHeight(); y++)
            for (int x = 0; x < dst.getWidth(); x++)
                dst.setPixel(linearToSRGBIfNeeded(dst.getFormat(), src.sample2D(sampler, filter, ((float)x + 0.5f) * sX,
                                                                                ((float)y + 0.5f) * sY, 0)),
                             x, y);
    }
    else
    {
        for (int z = 0; z < dst.getDepth(); z++)
            for (int y = 0; y < dst.getHeight(); y++)
                for (int x = 0; x < dst.getWidth(); x++)
                    dst.setPixel(linearToSRGBIfNeeded(dst.getFormat(),
                                                      src.sample3D(sampler, filter, ((float)x + 0.5f) * sX,
                                                                   ((float)y + 0.5f) * sY, ((float)z + 0.5f) * sZ)),
                                 x, y, z);
    }
}

void estimatePixelValueRange(const ConstPixelBufferAccess &access, Vec4 &minVal, Vec4 &maxVal)
{
    const TextureFormat &format = access.getFormat();

    switch (getTextureChannelClass(format.type))
    {
    case TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
        // Normalized unsigned formats.
        minVal = Vec4(0.0f);
        maxVal = Vec4(1.0f);
        break;

    case TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
        // Normalized signed formats.
        minVal = Vec4(-1.0f);
        maxVal = Vec4(+1.0f);
        break;

    default:
        // \note Samples every 4/8th pixel.
        minVal = Vec4(std::numeric_limits<float>::max());
        maxVal = Vec4(std::numeric_limits<float>::min());

        for (int z = 0; z < access.getDepth(); z += 2)
        {
            for (int y = 0; y < access.getHeight(); y += 2)
            {
                for (int x = 0; x < access.getWidth(); x += 2)
                {
                    Vec4 p = access.getPixel(x, y, z);

                    minVal[0] = (deFloatIsNaN(p[0]) ? minVal[0] : de::min(minVal[0], p[0]));
                    minVal[1] = (deFloatIsNaN(p[1]) ? minVal[1] : de::min(minVal[1], p[1]));
                    minVal[2] = (deFloatIsNaN(p[2]) ? minVal[2] : de::min(minVal[2], p[2]));
                    minVal[3] = (deFloatIsNaN(p[3]) ? minVal[3] : de::min(minVal[3], p[3]));

                    maxVal[0] = (deFloatIsNaN(p[0]) ? maxVal[0] : de::max(maxVal[0], p[0]));
                    maxVal[1] = (deFloatIsNaN(p[1]) ? maxVal[1] : de::max(maxVal[1], p[1]));
                    maxVal[2] = (deFloatIsNaN(p[2]) ? maxVal[2] : de::max(maxVal[2], p[2]));
                    maxVal[3] = (deFloatIsNaN(p[3]) ? maxVal[3] : de::max(maxVal[3], p[3]));
                }
            }
        }
        break;
    }
}

void computePixelScaleBias(const ConstPixelBufferAccess &access, Vec4 &scale, Vec4 &bias)
{
    Vec4 minVal, maxVal;
    estimatePixelValueRange(access, minVal, maxVal);

    const float eps = 0.0001f;

    for (int c = 0; c < 4; c++)
    {
        if (maxVal[c] - minVal[c] < eps)
        {
            scale[c] = (maxVal[c] < eps) ? 1.0f : (1.0f / maxVal[c]);
            bias[c]  = (c == 3) ? (1.0f - maxVal[c] * scale[c]) : (0.0f - minVal[c] * scale[c]);
        }
        else
        {
            scale[c] = 1.0f / (maxVal[c] - minVal[c]);
            bias[c]  = 0.0f - minVal[c] * scale[c];
        }
    }
}

int getCubeArrayFaceIndex(CubeFace face)
{
    DE_ASSERT((int)face >= 0 && face < CUBEFACE_LAST);

    switch (face)
    {
    case CUBEFACE_POSITIVE_X:
        return 0;
    case CUBEFACE_NEGATIVE_X:
        return 1;
    case CUBEFACE_POSITIVE_Y:
        return 2;
    case CUBEFACE_NEGATIVE_Y:
        return 3;
    case CUBEFACE_POSITIVE_Z:
        return 4;
    case CUBEFACE_NEGATIVE_Z:
        return 5;

    default:
        return -1;
    }
}

uint32_t packRGB999E5(const tcu::Vec4 &color)
{
    const int mBits    = 9;
    const int eBits    = 5;
    const int eBias    = 15;
    const int eMax     = (1 << eBits) - 1;
    const float maxVal = (float)(((1 << mBits) - 1) * (1 << (eMax - eBias))) / (float)(1 << mBits);

    float rc       = deFloatClamp(color[0], 0.0f, maxVal);
    float gc       = deFloatClamp(color[1], 0.0f, maxVal);
    float bc       = deFloatClamp(color[2], 0.0f, maxVal);
    float maxc     = de::max(rc, de::max(gc, bc));
    float log2c    = deFloatLog2(maxc);
    int32_t floorc = deIsInf(log2c) ? std::numeric_limits<int32_t>::min() : deFloorFloatToInt32(log2c);
    int exps       = de::max(-eBias - 1, floorc) + 1 + eBias;
    float e        = deFloatPow(2.0f, (float)(exps - eBias - mBits));
    int maxs       = deFloorFloatToInt32(maxc / e + 0.5f);

    if (maxs == (1 << mBits))
    {
        exps++;
        e *= 2.0f;
    }

    uint32_t rs = (uint32_t)deFloorFloatToInt32(rc / e + 0.5f);
    uint32_t gs = (uint32_t)deFloorFloatToInt32(gc / e + 0.5f);
    uint32_t bs = (uint32_t)deFloorFloatToInt32(bc / e + 0.5f);

    DE_ASSERT((exps & ~((1 << 5) - 1)) == 0);
    DE_ASSERT((rs & ~((1 << 9) - 1)) == 0);
    DE_ASSERT((gs & ~((1 << 9) - 1)) == 0);
    DE_ASSERT((bs & ~((1 << 9) - 1)) == 0);

    return rs | (gs << 9) | (bs << 18) | (exps << 27);
}

// Sampler utils

static const void *addOffset(const void *ptr, int numBytes)
{
    return (const uint8_t *)ptr + numBytes;
}

static void *addOffset(void *ptr, int numBytes)
{
    return (uint8_t *)ptr + numBytes;
}

template <typename AccessType>
static AccessType toSamplerAccess(const AccessType &baseAccess, Sampler::DepthStencilMode mode)
{
    // make sure to update this if type table is updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELTYPE_LAST == 48);

    if (!isCombinedDepthStencilType(baseAccess.getFormat().type))
        return baseAccess;
    else
    {
#if (DE_ENDIANNESS == DE_LITTLE_ENDIAN)
        const uint32_t uint32ByteOffsetBits0To8   = 0; //!< least significant byte in the lowest address
        const uint32_t uint32ByteOffsetBits0To24  = 0;
        const uint32_t uint32ByteOffsetBits8To32  = 1;
        const uint32_t uint32ByteOffsetBits16To32 = 2;
        const uint32_t uint32ByteOffsetBits24To32 = 3;
#else
        const uint32_t uint32ByteOffsetBits0To8   = 3; //!< least significant byte in the highest address
        const uint32_t uint32ByteOffsetBits0To24  = 1;
        const uint32_t uint32ByteOffsetBits8To32  = 0;
        const uint32_t uint32ByteOffsetBits16To32 = 0;
        const uint32_t uint32ByteOffsetBits24To32 = 0;
#endif

        // Sampled channel must exist
        DE_ASSERT(baseAccess.getFormat().order == TextureFormat::DS ||
                  (mode == Sampler::MODE_DEPTH && baseAccess.getFormat().order == TextureFormat::D) ||
                  (mode == Sampler::MODE_STENCIL && baseAccess.getFormat().order == TextureFormat::S));

        // combined formats have multiple channel classes, detect on sampler settings
        switch (baseAccess.getFormat().type)
        {
        case TextureFormat::FLOAT_UNSIGNED_INT_24_8_REV:
        {
            if (mode == Sampler::MODE_DEPTH)
            {
                // select the float component
                return AccessType(TextureFormat(TextureFormat::D, TextureFormat::FLOAT), baseAccess.getSize(),
                                  baseAccess.getPitch(), baseAccess.getDataPtr());
            }
            else if (mode == Sampler::MODE_STENCIL)
            {
                // select the uint 8 component
                return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), baseAccess.getSize(),
                                  baseAccess.getPitch(),
                                  addOffset(baseAccess.getDataPtr(), 4 + uint32ByteOffsetBits0To8));
            }
            else
            {
                // unknown sampler mode
                DE_ASSERT(false);
                return AccessType();
            }
        }

        case TextureFormat::UNSIGNED_INT_16_8_8:
        {
            if (mode == Sampler::MODE_DEPTH)
            {
                // select the unorm16 component
                return AccessType(TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT16), baseAccess.getSize(),
                                  baseAccess.getPitch(),
                                  addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits16To32));
            }
            else if (mode == Sampler::MODE_STENCIL)
            {
                // select the uint 8 component
                return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), baseAccess.getSize(),
                                  baseAccess.getPitch(), addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits0To8));
            }
            else
            {
                // unknown sampler mode
                DE_ASSERT(false);
                return AccessType();
            }
        }

        case TextureFormat::UNSIGNED_INT_24_8:
        {
            if (mode == Sampler::MODE_DEPTH)
            {
                // select the unorm24 component
                return AccessType(TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT24), baseAccess.getSize(),
                                  baseAccess.getPitch(), addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits8To32));
            }
            else if (mode == Sampler::MODE_STENCIL)
            {
                // select the uint 8 component
                return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), baseAccess.getSize(),
                                  baseAccess.getPitch(), addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits0To8));
            }
            else
            {
                // unknown sampler mode
                DE_ASSERT(false);
                return AccessType();
            }
        }

        case TextureFormat::UNSIGNED_INT_24_8_REV:
        {
            if (mode == Sampler::MODE_DEPTH)
            {
                // select the unorm24 component
                return AccessType(TextureFormat(TextureFormat::D, TextureFormat::UNORM_INT24), baseAccess.getSize(),
                                  baseAccess.getPitch(), addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits0To24));
            }
            else if (mode == Sampler::MODE_STENCIL)
            {
                // select the uint 8 component
                return AccessType(TextureFormat(TextureFormat::S, TextureFormat::UNSIGNED_INT8), baseAccess.getSize(),
                                  baseAccess.getPitch(),
                                  addOffset(baseAccess.getDataPtr(), uint32ByteOffsetBits24To32));
            }
            else
            {
                // unknown sampler mode
                DE_ASSERT(false);
                return AccessType();
            }
        }

        default:
        {
            // unknown combined format
            DE_ASSERT(false);
            return AccessType();
        }
        }
    }
}

PixelBufferAccess getEffectiveDepthStencilAccess(const PixelBufferAccess &baseAccess, Sampler::DepthStencilMode mode)
{
    return toSamplerAccess<PixelBufferAccess>(baseAccess, mode);
}

ConstPixelBufferAccess getEffectiveDepthStencilAccess(const ConstPixelBufferAccess &baseAccess,
                                                      Sampler::DepthStencilMode mode)
{
    return toSamplerAccess<ConstPixelBufferAccess>(baseAccess, mode);
}

TextureFormat getEffectiveDepthStencilTextureFormat(const TextureFormat &baseFormat, Sampler::DepthStencilMode mode)
{
    return toSamplerAccess(ConstPixelBufferAccess(baseFormat, IVec3(0, 0, 0), DE_NULL), mode).getFormat();
}

template <typename ViewType>
ViewType getEffectiveTView(const ViewType &src, std::vector<tcu::ConstPixelBufferAccess> &storage,
                           const tcu::Sampler &sampler)
{
    storage.resize(src.getNumLevels());

    ViewType view = ViewType(src.getNumLevels(), &storage[0], src.isES2(), src.getImageViewMinLodParams());

    for (int levelNdx = 0; levelNdx < src.getNumLevels(); ++levelNdx)
        storage[levelNdx] = tcu::getEffectiveDepthStencilAccess(src.getLevel(levelNdx), sampler.depthStencilMode);

    return view;
}

tcu::TextureCubeView getEffectiveTView(const tcu::TextureCubeView &src,
                                       std::vector<tcu::ConstPixelBufferAccess> &storage, const tcu::Sampler &sampler)
{
    storage.resize(tcu::CUBEFACE_LAST * src.getNumLevels());

    const tcu::ConstPixelBufferAccess *storagePtrs[tcu::CUBEFACE_LAST] = {
        &storage[0 * src.getNumLevels()], &storage[1 * src.getNumLevels()], &storage[2 * src.getNumLevels()],
        &storage[3 * src.getNumLevels()], &storage[4 * src.getNumLevels()], &storage[5 * src.getNumLevels()],
    };

    tcu::TextureCubeView view =
        tcu::TextureCubeView(src.getNumLevels(), storagePtrs, false, src.getImageViewMinLodParams());

    for (int faceNdx = 0; faceNdx < tcu::CUBEFACE_LAST; ++faceNdx)
        for (int levelNdx = 0; levelNdx < src.getNumLevels(); ++levelNdx)
            storage[faceNdx * src.getNumLevels() + levelNdx] = tcu::getEffectiveDepthStencilAccess(
                src.getLevelFace(levelNdx, (tcu::CubeFace)faceNdx), sampler.depthStencilMode);

    return view;
}

tcu::Texture1DView getEffectiveTextureView(const tcu::Texture1DView &src,
                                           std::vector<tcu::ConstPixelBufferAccess> &storage,
                                           const tcu::Sampler &sampler)
{
    return getEffectiveTView(src, storage, sampler);
}

tcu::Texture2DView getEffectiveTextureView(const tcu::Texture2DView &src,
                                           std::vector<tcu::ConstPixelBufferAccess> &storage,
                                           const tcu::Sampler &sampler)
{
    return getEffectiveTView(src, storage, sampler);
}

tcu::Texture3DView getEffectiveTextureView(const tcu::Texture3DView &src,
                                           std::vector<tcu::ConstPixelBufferAccess> &storage,
                                           const tcu::Sampler &sampler)
{
    return getEffectiveTView(src, storage, sampler);
}

tcu::Texture1DArrayView getEffectiveTextureView(const tcu::Texture1DArrayView &src,
                                                std::vector<tcu::ConstPixelBufferAccess> &storage,
                                                const tcu::Sampler &sampler)
{
    return getEffectiveTView(src, storage, sampler);
}

tcu::Texture2DArrayView getEffectiveTextureView(const tcu::Texture2DArrayView &src,
                                                std::vector<tcu::ConstPixelBufferAccess> &storage,
                                                const tcu::Sampler &sampler)
{
    return getEffectiveTView(src, storage, sampler);
}

tcu::TextureCubeView getEffectiveTextureView(const tcu::TextureCubeView &src,
                                             std::vector<tcu::ConstPixelBufferAccess> &storage,
                                             const tcu::Sampler &sampler)
{
    return getEffectiveTView(src, storage, sampler);
}

tcu::TextureCubeArrayView getEffectiveTextureView(const tcu::TextureCubeArrayView &src,
                                                  std::vector<tcu::ConstPixelBufferAccess> &storage,
                                                  const tcu::Sampler &sampler)
{
    return getEffectiveTView(src, storage, sampler);
}

//! Returns the effective swizzle of a border color. The effective swizzle is the
//! equal to first writing an RGBA color with a write swizzle and then reading
//! it back using a read swizzle, i.e. BorderSwizzle(c) == readSwizzle(writeSwizzle(C))
static const TextureSwizzle &getBorderColorReadSwizzle(TextureFormat::ChannelOrder order)
{
    // make sure to update these tables when channel orders are updated
    DE_STATIC_ASSERT(TextureFormat::CHANNELORDER_LAST == 22);

    static const TextureSwizzle INV = {{TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO,
                                        TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE}};
    static const TextureSwizzle R   = {{TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO,
                                        TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE}};
    static const TextureSwizzle A   = {{TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ZERO,
                                        TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_3}};
    static const TextureSwizzle I   = {
        {TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0}};
    static const TextureSwizzle L = {
        {TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ONE}};
    static const TextureSwizzle LA = {
        {TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3}};
    static const TextureSwizzle RG  = {{TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1,
                                        TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE}};
    static const TextureSwizzle RA  = {{TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO,
                                        TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_3}};
    static const TextureSwizzle RGB = {
        {TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_ONE}};
    static const TextureSwizzle RGBA = {
        {TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_1, TextureSwizzle::CHANNEL_2, TextureSwizzle::CHANNEL_3}};
    static const TextureSwizzle D = {{TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO,
                                      TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE}};
    static const TextureSwizzle S = {{TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_ZERO,
                                      TextureSwizzle::CHANNEL_ZERO, TextureSwizzle::CHANNEL_ONE}};

    const TextureSwizzle *swizzle;

    switch (order)
    {
    case TextureFormat::R:
        swizzle = &R;
        break;
    case TextureFormat::A:
        swizzle = &A;
        break;
    case TextureFormat::I:
        swizzle = &I;
        break;
    case TextureFormat::L:
        swizzle = &L;
        break;
    case TextureFormat::LA:
        swizzle = &LA;
        break;
    case TextureFormat::RG:
        swizzle = &RG;
        break;
    case TextureFormat::RA:
        swizzle = &RA;
        break;
    case TextureFormat::RGB:
        swizzle = &RGB;
        break;
    case TextureFormat::RGBA:
        swizzle = &RGBA;
        break;
    case TextureFormat::ARGB:
        swizzle = &RGBA;
        break;
    case TextureFormat::ABGR:
        swizzle = &RGBA;
        break;
    case TextureFormat::BGR:
        swizzle = &RGB;
        break;
    case TextureFormat::BGRA:
        swizzle = &RGBA;
        break;
    case TextureFormat::sR:
        swizzle = &R;
        break;
    case TextureFormat::sRG:
        swizzle = &RG;
        break;
    case TextureFormat::sRGB:
        swizzle = &RGB;
        break;
    case TextureFormat::sRGBA:
        swizzle = &RGBA;
        break;
    case TextureFormat::sBGR:
        swizzle = &RGB;
        break;
    case TextureFormat::sBGRA:
        swizzle = &RGBA;
        break;
    case TextureFormat::D:
        swizzle = &D;
        break;
    case TextureFormat::S:
        swizzle = &S;
        break;

    case TextureFormat::DS:
        DE_ASSERT(false); // combined depth-stencil border color?
        swizzle = &INV;
        break;

    default:
        DE_ASSERT(false);
        swizzle = &INV;
        break;
    }

#ifdef DE_DEBUG

    {
        // check that BorderSwizzle(c) == readSwizzle(writeSwizzle(C))
        const TextureSwizzle &readSwizzle  = getChannelReadSwizzle(order);
        const TextureSwizzle &writeSwizzle = getChannelWriteSwizzle(order);

        for (int ndx = 0; ndx < 4; ++ndx)
        {
            TextureSwizzle::Channel writeRead = readSwizzle.components[ndx];
            if (deInRange32(writeRead, TextureSwizzle::CHANNEL_0, TextureSwizzle::CHANNEL_3) == true)
                writeRead = writeSwizzle.components[(int)writeRead];
            DE_ASSERT(writeRead == swizzle->components[ndx]);
        }
    }

#endif

    return *swizzle;
}

static tcu::UVec4 getNBitUnsignedIntegerVec4MaxValue(const tcu::IVec4 &numBits)
{
    return tcu::UVec4((numBits[0] > 0) ? (deUintMaxValue32(numBits[0])) : (0),
                      (numBits[1] > 0) ? (deUintMaxValue32(numBits[1])) : (0),
                      (numBits[2] > 0) ? (deUintMaxValue32(numBits[2])) : (0),
                      (numBits[3] > 0) ? (deUintMaxValue32(numBits[3])) : (0));
}

static tcu::IVec4 getNBitSignedIntegerVec4MaxValue(const tcu::IVec4 &numBits)
{
    return tcu::IVec4(
        (numBits[0] > 0) ? (deIntMaxValue32(numBits[0])) : (0), (numBits[1] > 0) ? (deIntMaxValue32(numBits[1])) : (0),
        (numBits[2] > 0) ? (deIntMaxValue32(numBits[2])) : (0), (numBits[3] > 0) ? (deIntMaxValue32(numBits[3])) : (0));
}

static tcu::IVec4 getNBitSignedIntegerVec4MinValue(const tcu::IVec4 &numBits)
{
    return tcu::IVec4(
        (numBits[0] > 0) ? (deIntMinValue32(numBits[0])) : (0), (numBits[1] > 0) ? (deIntMinValue32(numBits[1])) : (0),
        (numBits[2] > 0) ? (deIntMinValue32(numBits[2])) : (0), (numBits[3] > 0) ? (deIntMinValue32(numBits[3])) : (0));
}

static tcu::Vec4 getTextureBorderColorFloat(const TextureFormat &format, const Sampler &sampler)
{
    const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type);
    const TextureSwizzle::Channel *channelMap   = getBorderColorReadSwizzle(format.order).components;
    const bool isFloat                          = channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT;
    const bool isSigned                         = channelClass != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT;
    const float valueMin                        = (isSigned) ? (-1.0f) : (0.0f);
    const float valueMax                        = 1.0f;
    Vec4 result;

    DE_ASSERT(channelClass == tcu::TEXTURECHANNELCLASS_FLOATING_POINT ||
              channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT ||
              channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT);

    for (int c = 0; c < 4; c++)
    {
        const TextureSwizzle::Channel map = channelMap[c];
        if (map == TextureSwizzle::CHANNEL_ZERO)
            result[c] = 0.0f;
        else if (map == TextureSwizzle::CHANNEL_ONE)
            result[c] = 1.0f;
        else if (isFloat)
        {
            // floating point values are not clamped
            result[c] = sampler.borderColor.getAccess<float>()[(int)map];
        }
        else
        {
            // fixed point values are clamped to a representable range
            result[c] = de::clamp(sampler.borderColor.getAccess<float>()[(int)map], valueMin, valueMax);
        }
    }

    return result;
}

static tcu::IVec4 getTextureBorderColorInt(const TextureFormat &format, const Sampler &sampler)
{
    const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type);
    const TextureSwizzle::Channel *channelMap   = getBorderColorReadSwizzle(format.order).components;
    const IVec4 channelBits                     = getChannelBitDepth(format.type);
    const IVec4 valueMin                        = getNBitSignedIntegerVec4MinValue(channelBits);
    const IVec4 valueMax                        = getNBitSignedIntegerVec4MaxValue(channelBits);
    IVec4 result;

    DE_ASSERT(channelClass == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER);
    DE_UNREF(channelClass);

    for (int c = 0; c < 4; c++)
    {
        const TextureSwizzle::Channel map = channelMap[c];
        if (map == TextureSwizzle::CHANNEL_ZERO)
            result[c] = 0;
        else if (map == TextureSwizzle::CHANNEL_ONE)
            result[c] = 1;
        else
        {
            // integer values are clamped to a representable range
            result[c] =
                de::clamp(sampler.borderColor.getAccess<int32_t>()[(int)map], valueMin[(int)map], valueMax[(int)map]);
        }
    }

    return result;
}

static tcu::UVec4 getTextureBorderColorUint(const TextureFormat &format, const Sampler &sampler)
{
    const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type);
    const TextureSwizzle::Channel *channelMap   = getBorderColorReadSwizzle(format.order).components;
    const IVec4 channelBits                     = getChannelBitDepth(format.type);
    const UVec4 valueMax                        = getNBitUnsignedIntegerVec4MaxValue(channelBits);
    UVec4 result;

    DE_ASSERT(channelClass == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER);
    DE_UNREF(channelClass);

    for (int c = 0; c < 4; c++)
    {
        const TextureSwizzle::Channel map = channelMap[c];
        if (map == TextureSwizzle::CHANNEL_ZERO)
            result[c] = 0;
        else if (map == TextureSwizzle::CHANNEL_ONE)
            result[c] = 1;
        else
        {
            // integer values are clamped to a representable range
            result[c] = de::min(sampler.borderColor.getAccess<uint32_t>()[(int)map], valueMax[(int)map]);
        }
    }

    return result;
}

template <typename ScalarType>
tcu::Vector<ScalarType, 4> sampleTextureBorder(const TextureFormat &format, const Sampler &sampler)
{
    const tcu::TextureChannelClass channelClass = getTextureChannelClass(format.type);

    switch (channelClass)
    {
    case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
    case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
    case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
        return getTextureBorderColorFloat(format, sampler).cast<ScalarType>();

    case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
        return getTextureBorderColorInt(format, sampler).cast<ScalarType>();

    case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
        return getTextureBorderColorUint(format, sampler).cast<ScalarType>();

    default:
        DE_ASSERT(false);
        return tcu::Vector<ScalarType, 4>();
    }
}

// instantiation
template tcu::Vector<float, 4> sampleTextureBorder(const TextureFormat &format, const Sampler &sampler);
template tcu::Vector<int32_t, 4> sampleTextureBorder(const TextureFormat &format, const Sampler &sampler);
template tcu::Vector<uint32_t, 4> sampleTextureBorder(const TextureFormat &format, const Sampler &sampler);

} // namespace tcu