#ifndef _TCUTEXTUREUTIL_HPP
#define _TCUTEXTUREUTIL_HPP
/*-------------------------------------------------------------------------
 * 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 "tcuDefs.hpp"
#include "tcuTexture.hpp"

namespace tcu
{

// PixelBufferAccess utilities.
PixelBufferAccess getSubregion(const PixelBufferAccess &access, int x, int y, int z, int width, int height, int depth);
ConstPixelBufferAccess getSubregion(const ConstPixelBufferAccess &access, int x, int y, int z, int width, int height,
                                    int depth);

PixelBufferAccess getSubregion(const PixelBufferAccess &access, int x, int y, int width, int height);
ConstPixelBufferAccess getSubregion(const ConstPixelBufferAccess &access, int x, int y, int width, int height);

PixelBufferAccess flipYAccess(const PixelBufferAccess &access);
ConstPixelBufferAccess flipYAccess(const ConstPixelBufferAccess &access);

bool isCombinedDepthStencilType(TextureFormat::ChannelType type);
bool hasStencilComponent(TextureFormat::ChannelOrder order);
bool hasDepthComponent(TextureFormat::ChannelOrder order);

// sRGB - linear conversion.
float linearChannelToSRGB(float cl);
float sRGBChannelToLinear(float cl);
Vec4 sRGBToLinear(const Vec4 &cs);
Vec4 sRGB8ToLinear(const UVec4 &cs);
Vec4 sRGBA8ToLinear(const UVec4 &cs);
Vec4 linearToSRGB(const Vec4 &cl);
bool isSRGB(TextureFormat format);

/*--------------------------------------------------------------------*//*!
 * \brief Color channel storage type
 *//*--------------------------------------------------------------------*/
enum TextureChannelClass
{
    TEXTURECHANNELCLASS_SIGNED_FIXED_POINT = 0,
    TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT,
    TEXTURECHANNELCLASS_SIGNED_INTEGER,
    TEXTURECHANNELCLASS_UNSIGNED_INTEGER,
    TEXTURECHANNELCLASS_FLOATING_POINT,

    TEXTURECHANNELCLASS_LAST
};

TextureChannelClass getTextureChannelClass(TextureFormat::ChannelType channelType);

/*--------------------------------------------------------------------*//*!
 * \brief Texture access type
 *//*--------------------------------------------------------------------*/
enum TextureAccessType
{
    TEXTUREACCESSTYPE_FLOAT = 0,    //!< Read (getPixel) or write as floating-point data
    TEXTUREACCESSTYPE_SIGNED_INT,   //!< Read (getPixelInt) or write as signed integer data
    TEXTUREACCESSTYPE_UNSIGNED_INT, //!< Read (getPixelUint) or write as unsigned integer data

    TEXTUREACCESSTYPE_LAST
};

bool isAccessValid(TextureFormat format, TextureAccessType type);

/*--------------------------------------------------------------------*//*!
 * \brief Standard parameters for texture format testing
 *//*--------------------------------------------------------------------*/
struct TextureFormatInfo
{
    Vec4 valueMin;
    Vec4 valueMax;
    Vec4 lookupScale;
    Vec4 lookupBias;

    TextureFormatInfo(const Vec4 &valueMin_, const Vec4 &valueMax_, const Vec4 &lookupScale_, const Vec4 &lookupBias_)
        : valueMin(valueMin_)
        , valueMax(valueMax_)
        , lookupScale(lookupScale_)
        , lookupBias(lookupBias_)
    {
    }
} DE_WARN_UNUSED_TYPE;

TextureFormatInfo getTextureFormatInfo(const TextureFormat &format);
IVec4 getTextureFormatBitDepth(const TextureFormat &format);
IVec4 getTextureFormatMantissaBitDepth(const TextureFormat &format);
BVec4 getTextureFormatChannelMask(const TextureFormat &format);

IVec4 getFormatMinIntValue(const TextureFormat &format);
IVec4 getFormatMaxIntValue(const TextureFormat &format);

UVec4 getFormatMaxUintValue(const TextureFormat &format);

// Texture fill.
void clear(const PixelBufferAccess &access, const Vec4 &color);
void clear(const PixelBufferAccess &access, const IVec4 &color);
void clear(const PixelBufferAccess &access, const UVec4 &color);
void clearDepth(const PixelBufferAccess &access, float depth);
void clearStencil(const PixelBufferAccess &access, int stencil);
void fillWithComponentGradients(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal);
void fillWithComponentGradients2(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal);
void fillWithComponentGradients3(const PixelBufferAccess &access, const Vec4 &minVal, const Vec4 &maxVal);
void fillWithGrid(const PixelBufferAccess &access, int cellSize, const Vec4 &colorA, const Vec4 &colorB);
void fillWithRepeatableGradient(const PixelBufferAccess &access, const Vec4 &colorA, const Vec4 &colorB);
void fillWithMetaballs(const PixelBufferAccess &access, int numMetaballs, uint32_t seed);
void fillWithRGBAQuads(const PixelBufferAccess &access);

//! Copies contents of src to dst. If formats of dst and src are equal, a bit-exact copy is made.
void copy(const PixelBufferAccess &dst, const ConstPixelBufferAccess &src, const bool clearUnused = true);

void scale(const PixelBufferAccess &dst, const ConstPixelBufferAccess &src, Sampler::FilterMode filter);

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

int getCubeArrayFaceIndex(CubeFace face);

//! FP32->U8 with RTE rounding (extremely fast, always accurate).
inline uint8_t floatToU8(float fv)
{
    union
    {
        float fv;
        uint32_t uv;
        int32_t iv;
    } v;
    v.fv = fv;

    const uint32_t e = (uint32_t)(126 - (v.iv >> 23));
    uint32_t m       = v.uv;

    m &= 0x00ffffffu;
    m |= 0x00800000u;
    m = (m << 8) - m;
    m = (e > 8) ? e : (0x00800000u + (m >> e));

    return (uint8_t)(m >> 24);
}

uint32_t packRGB999E5(const tcu::Vec4 &color);

/*--------------------------------------------------------------------*//*!
 * \brief Depth-stencil utilities
 *//*--------------------------------------------------------------------*/

TextureFormat getEffectiveDepthStencilTextureFormat(const TextureFormat &baseFormat, Sampler::DepthStencilMode mode);

//! returns the currently effective access to an access with a given sampler mode, e.g.
//! for combined depth stencil accesses and for sampler set to sample stencil returns
//! stencil access. Identity for non-combined formats.
PixelBufferAccess getEffectiveDepthStencilAccess(const PixelBufferAccess &baseAccess, Sampler::DepthStencilMode mode);
ConstPixelBufferAccess getEffectiveDepthStencilAccess(const ConstPixelBufferAccess &baseAccess,
                                                      Sampler::DepthStencilMode mode);

//! returns the currently effective view to an texture with a given sampler mode. Uses
//! storage for access storage storage

tcu::Texture1DView getEffectiveTextureView(const tcu::Texture1DView &src,
                                           std::vector<tcu::ConstPixelBufferAccess> &storage,
                                           const tcu::Sampler &sampler);
tcu::Texture2DView getEffectiveTextureView(const tcu::Texture2DView &src,
                                           std::vector<tcu::ConstPixelBufferAccess> &storage,
                                           const tcu::Sampler &sampler);
tcu::Texture3DView getEffectiveTextureView(const tcu::Texture3DView &src,
                                           std::vector<tcu::ConstPixelBufferAccess> &storage,
                                           const tcu::Sampler &sampler);
tcu::Texture1DArrayView getEffectiveTextureView(const tcu::Texture1DArrayView &src,
                                                std::vector<tcu::ConstPixelBufferAccess> &storage,
                                                const tcu::Sampler &sampler);
tcu::Texture2DArrayView getEffectiveTextureView(const tcu::Texture2DArrayView &src,
                                                std::vector<tcu::ConstPixelBufferAccess> &storage,
                                                const tcu::Sampler &sampler);
tcu::TextureCubeView getEffectiveTextureView(const tcu::TextureCubeView &src,
                                             std::vector<tcu::ConstPixelBufferAccess> &storage,
                                             const tcu::Sampler &sampler);
tcu::TextureCubeArrayView getEffectiveTextureView(const tcu::TextureCubeArrayView &src,
                                                  std::vector<tcu::ConstPixelBufferAccess> &storage,
                                                  const tcu::Sampler &sampler);

template <typename ScalarType>
tcu::Vector<ScalarType, 4> sampleTextureBorder(const TextureFormat &format, const Sampler &sampler);

} // namespace tcu

#endif // _TCUTEXTUREUTIL_HPP