Google Git
Sign in
fuchsia / third_party / vulkan-cts / 67d7ed7f78f2f13ab3c1fa99ebcca5a44677bf2d / . / framework / common / tcuCompressedTexture.cpp
blob: 3af1a7f7405c1965074efec635bde632522b0b47 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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 Compressed Texture Utilities.
*//*--------------------------------------------------------------------*/
#include "tcuCompressedTexture.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuAstcUtil.hpp"
#include "deStringUtil.hpp"
#include "deFloat16.h"
#include <algorithm>
namespace tcu
{
int getBlockSize (CompressedTexFormat format)
{
if (isAstcFormat(format))
{
return astc::BLOCK_SIZE_BYTES;
}
else if (isEtcFormat(format))
{
switch (format)
{
case COMPRESSEDTEXFORMAT_ETC1_RGB8: return 8;
case COMPRESSEDTEXFORMAT_EAC_R11: return 8;
case COMPRESSEDTEXFORMAT_EAC_SIGNED_R11: return 8;
case COMPRESSEDTEXFORMAT_EAC_RG11: return 16;
case COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11: return 16;
case COMPRESSEDTEXFORMAT_ETC2_RGB8: return 8;
case COMPRESSEDTEXFORMAT_ETC2_SRGB8: return 8;
case COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: return 8;
case COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: return 8;
case COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8: return 16;
case COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8: return 16;
default:
DE_ASSERT(false);
return -1;
}
}
else if (isBcFormat(format))
{
switch (format)
{
case COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK: return 8;
case COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK: return 8;
case COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK: return 8;
case COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK: return 8;
case COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK: return 8;
case COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK: return 8;
case COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK: return 16;
case COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK: return 16;
default:
DE_ASSERT(false);
return -1;
}
}
else
{
DE_ASSERT(false);
return -1;
}
}
IVec3 getBlockPixelSize (CompressedTexFormat format)
{
if (isEtcFormat(format))
{
return IVec3(4, 4, 1);
}
else if (isAstcFormat(format))
{
switch (format)
{
case COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA: return IVec3(4, 4, 1);
case COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA: return IVec3(5, 4, 1);
case COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA: return IVec3(5, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA: return IVec3(6, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA: return IVec3(6, 6, 1);
case COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA: return IVec3(8, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA: return IVec3(8, 6, 1);
case COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA: return IVec3(8, 8, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA: return IVec3(10, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA: return IVec3(10, 6, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA: return IVec3(10, 8, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA: return IVec3(10, 10, 1);
case COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA: return IVec3(12, 10, 1);
case COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA: return IVec3(12, 12, 1);
case COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8: return IVec3(4, 4, 1);
case COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8: return IVec3(5, 4, 1);
case COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8: return IVec3(5, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8: return IVec3(6, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8: return IVec3(6, 6, 1);
case COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8: return IVec3(8, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8: return IVec3(8, 6, 1);
case COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8: return IVec3(8, 8, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8: return IVec3(10, 5, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8: return IVec3(10, 6, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8: return IVec3(10, 8, 1);
case COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8: return IVec3(10, 10, 1);
case COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8: return IVec3(12, 10, 1);
case COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8: return IVec3(12, 12, 1);
default:
DE_ASSERT(false);
return IVec3();
}
}
else if (isBcFormat(format))
{
return IVec3(4, 4, 1);
}
else
{
DE_ASSERT(false);
return IVec3(-1);
}
}
bool isEtcFormat (CompressedTexFormat format)
{
switch (format)
{
case COMPRESSEDTEXFORMAT_ETC1_RGB8:
case COMPRESSEDTEXFORMAT_EAC_R11:
case COMPRESSEDTEXFORMAT_EAC_SIGNED_R11:
case COMPRESSEDTEXFORMAT_EAC_RG11:
case COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11:
case COMPRESSEDTEXFORMAT_ETC2_RGB8:
case COMPRESSEDTEXFORMAT_ETC2_SRGB8:
case COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1:
case COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1:
case COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8:
case COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8:
return true;
default:
return false;
}
}
bool isBcFormat (CompressedTexFormat format)
{
switch (format)
{
case COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK:
case COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK:
case COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK:
return true;
default:
return false;
}
}
bool isBcBitExactFormat (CompressedTexFormat format)
{
switch (format)
{
case COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK:
case COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK:
case COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK:
case COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK:
return true;
default:
return false;
}
}
bool isBcSRGBFormat (CompressedTexFormat format)
{
switch (format)
{
case COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK:
case COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK:
return true;
default:
return false;
}
}
bool isAstcFormat (CompressedTexFormat format)
{
switch (format)
{
case COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8:
return true;
default:
return false;
}
}
bool isAstcSRGBFormat (CompressedTexFormat format)
{
switch (format)
{
case COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8:
return true;
default:
return false;
}
}
TextureFormat getUncompressedFormat (CompressedTexFormat format)
{
if (isEtcFormat(format))
{
switch (format)
{
case COMPRESSEDTEXFORMAT_ETC1_RGB8: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
case COMPRESSEDTEXFORMAT_EAC_R11: return TextureFormat(TextureFormat::R, TextureFormat::UNORM_INT16);
case COMPRESSEDTEXFORMAT_EAC_SIGNED_R11: return TextureFormat(TextureFormat::R, TextureFormat::SNORM_INT16);
case COMPRESSEDTEXFORMAT_EAC_RG11: return TextureFormat(TextureFormat::RG, TextureFormat::UNORM_INT16);
case COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11: return TextureFormat(TextureFormat::RG, TextureFormat::SNORM_INT16);
case COMPRESSEDTEXFORMAT_ETC2_RGB8: return TextureFormat(TextureFormat::RGB, TextureFormat::UNORM_INT8);
case COMPRESSEDTEXFORMAT_ETC2_SRGB8: return TextureFormat(TextureFormat::sRGB, TextureFormat::UNORM_INT8);
case COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
case COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
case COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8: return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
case COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8: return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
default:
DE_ASSERT(false);
return TextureFormat();
}
}
else if (isAstcFormat(format))
{
if (isAstcSRGBFormat(format))
return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
else
return TextureFormat(TextureFormat::RGBA, TextureFormat::HALF_FLOAT);
}
else if (isBcFormat(format))
{
if (format == COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK || format == COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK)
return TextureFormat(TextureFormat::R, TextureFormat::FLOAT);
else if (format == COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK || format == COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK)
return TextureFormat(TextureFormat::RG, TextureFormat::FLOAT);
else if (format == COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK || format == COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK)
return TextureFormat(TextureFormat::RGB, TextureFormat::HALF_FLOAT);
else if (isBcSRGBFormat(format))
return TextureFormat(TextureFormat::sRGBA, TextureFormat::UNORM_INT8);
else
return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
}
else
{
DE_ASSERT(false);
return TextureFormat();
}
}
CompressedTexFormat getAstcFormatByBlockSize (const IVec3& size, bool isSRGB)
{
if (size.z() > 1)
throw InternalError("3D ASTC textures not currently supported");
for (int fmtI = 0; fmtI < COMPRESSEDTEXFORMAT_LAST; fmtI++)
{
const CompressedTexFormat fmt = (CompressedTexFormat)fmtI;
if (isAstcFormat(fmt) && getBlockPixelSize(fmt) == size && isAstcSRGBFormat(fmt) == isSRGB)
return fmt;
}
throw InternalError("Invalid ASTC block size " + de::toString(size.x()) + "x" + de::toString(size.y()) + "x" + de::toString(size.z()));
}
namespace
{
inline deUint8 extend4To8 (deUint8 src)
{
DE_ASSERT((src & ~((1<<4)-1)) == 0);
return (deUint8)((src << 4) | src);
}
inline deUint8 extend5To8 (deUint8 src)
{
DE_ASSERT((src & ~((1<<5)-1)) == 0);
return (deUint8)((src << 3) | (src >> 2));
}
inline deUint8 extend6To8 (deUint8 src)
{
DE_ASSERT((src & ~((1<<6)-1)) == 0);
return (deUint8)((src << 2) | (src >> 4));
}
// \todo [2013-08-06 nuutti] ETC and ASTC decompression codes are rather unrelated, and are already in their own "private" namespaces - should this be split to multiple files?
namespace EtcDecompressInternal
{
enum
{
ETC2_BLOCK_WIDTH = 4,
ETC2_BLOCK_HEIGHT = 4,
ETC2_UNCOMPRESSED_PIXEL_SIZE_A8 = 1,
ETC2_UNCOMPRESSED_PIXEL_SIZE_R11 = 2,
ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11 = 4,
ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8 = 3,
ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 = 4,
ETC2_UNCOMPRESSED_BLOCK_SIZE_A8 = ETC2_BLOCK_WIDTH*ETC2_BLOCK_HEIGHT*ETC2_UNCOMPRESSED_PIXEL_SIZE_A8,
ETC2_UNCOMPRESSED_BLOCK_SIZE_R11 = ETC2_BLOCK_WIDTH*ETC2_BLOCK_HEIGHT*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11,
ETC2_UNCOMPRESSED_BLOCK_SIZE_RG11 = ETC2_BLOCK_WIDTH*ETC2_BLOCK_HEIGHT*ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11,
ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8 = ETC2_BLOCK_WIDTH*ETC2_BLOCK_HEIGHT*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8,
ETC2_UNCOMPRESSED_BLOCK_SIZE_RGBA8 = ETC2_BLOCK_WIDTH*ETC2_BLOCK_HEIGHT*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8
};
inline deUint64 get64BitBlock (const deUint8* src, int blockNdx)
{
// Stored in big-endian form.
deUint64 block = 0;
for (int i = 0; i < 8; i++)
block = (block << 8ull) | (deUint64)(src[blockNdx*8+i]);
return block;
}
// Return the first 64 bits of a 128 bit block.
inline deUint64 get128BitBlockStart (const deUint8* src, int blockNdx)
{
return get64BitBlock(src, 2*blockNdx);
}
// Return the last 64 bits of a 128 bit block.
inline deUint64 get128BitBlockEnd (const deUint8* src, int blockNdx)
{
return get64BitBlock(src, 2*blockNdx + 1);
}
inline deUint32 getBit (deUint64 src, int bit)
{
return (src >> bit) & 1;
}
inline deUint32 getBits (deUint64 src, int low, int high)
{
const int numBits = (high-low) + 1;
DE_ASSERT(de::inRange(numBits, 1, 32));
if (numBits < 32)
return (deUint32)((src >> low) & ((1u<<numBits)-1));
else
return (deUint32)((src >> low) & 0xFFFFFFFFu);
}
inline deUint8 extend7To8 (deUint8 src)
{
DE_ASSERT((src & ~((1<<7)-1)) == 0);
return (deUint8)((src << 1) | (src >> 6));
}
inline deInt8 extendSigned3To8 (deUint8 src)
{
const bool isNeg = (src & (1<<2)) != 0;
return (deInt8)((isNeg ? ~((1<<3)-1) : 0) | src);
}
inline deUint8 extend5Delta3To8 (deUint8 base5, deUint8 delta3)
{
const deUint8 t = (deUint8)((deInt8)base5 + extendSigned3To8(delta3));
return extend5To8(t);
}
inline deUint16 extend11To16 (deUint16 src)
{
DE_ASSERT((src & ~((1<<11)-1)) == 0);
return (deUint16)((src << 5) | (src >> 6));
}
inline deInt16 extend11To16WithSign (deInt16 src)
{
if (src < 0)
return (deInt16)(-(deInt16)extend11To16((deUint16)(-src)));
else
return (deInt16)extend11To16(src);
}
void decompressETC1Block (deUint8 dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8], deUint64 src)
{
const int diffBit = (int)getBit(src, 33);
const int flipBit = (int)getBit(src, 32);
const deUint32 table[2] = { getBits(src, 37, 39), getBits(src, 34, 36) };
deUint8 baseR[2];
deUint8 baseG[2];
deUint8 baseB[2];
if (diffBit == 0)
{
// Individual mode.
baseR[0] = extend4To8((deUint8)getBits(src, 60, 63));
baseR[1] = extend4To8((deUint8)getBits(src, 56, 59));
baseG[0] = extend4To8((deUint8)getBits(src, 52, 55));
baseG[1] = extend4To8((deUint8)getBits(src, 48, 51));
baseB[0] = extend4To8((deUint8)getBits(src, 44, 47));
baseB[1] = extend4To8((deUint8)getBits(src, 40, 43));
}
else
{
// Differential mode (diffBit == 1).
deUint8 bR = (deUint8)getBits(src, 59, 63); // 5b
deUint8 dR = (deUint8)getBits(src, 56, 58); // 3b
deUint8 bG = (deUint8)getBits(src, 51, 55);
deUint8 dG = (deUint8)getBits(src, 48, 50);
deUint8 bB = (deUint8)getBits(src, 43, 47);
deUint8 dB = (deUint8)getBits(src, 40, 42);
baseR[0] = extend5To8(bR);
baseG[0] = extend5To8(bG);
baseB[0] = extend5To8(bB);
baseR[1] = extend5Delta3To8(bR, dR);
baseG[1] = extend5Delta3To8(bG, dG);
baseB[1] = extend5Delta3To8(bB, dB);
}
static const int modifierTable[8][4] =
{
// 00 01 10 11
{ 2, 8, -2, -8 },
{ 5, 17, -5, -17 },
{ 9, 29, -9, -29 },
{ 13, 42, -13, -42 },
{ 18, 60, -18, -60 },
{ 24, 80, -24, -80 },
{ 33, 106, -33, -106 },
{ 47, 183, -47, -183 }
};
// Write final pixels.
for (int pixelNdx = 0; pixelNdx < ETC2_BLOCK_HEIGHT*ETC2_BLOCK_WIDTH; pixelNdx++)
{
const int x = pixelNdx / ETC2_BLOCK_HEIGHT;
const int y = pixelNdx % ETC2_BLOCK_HEIGHT;
const int dstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8;
const int subBlock = ((flipBit ? y : x) >= 2) ? 1 : 0;
const deUint32 tableNdx = table[subBlock];
const deUint32 modifierNdx = (getBit(src, 16+pixelNdx) << 1) | getBit(src, pixelNdx);
const int modifier = modifierTable[tableNdx][modifierNdx];
dst[dstOffset+0] = (deUint8)deClamp32((int)baseR[subBlock] + modifier, 0, 255);
dst[dstOffset+1] = (deUint8)deClamp32((int)baseG[subBlock] + modifier, 0, 255);
dst[dstOffset+2] = (deUint8)deClamp32((int)baseB[subBlock] + modifier, 0, 255);
}
}
// if alphaMode is true, do PUNCHTHROUGH and store alpha to alphaDst; otherwise do ordinary ETC2 RGB8.
void decompressETC2Block (deUint8 dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8], deUint64 src, deUint8 alphaDst[ETC2_UNCOMPRESSED_BLOCK_SIZE_A8], bool alphaMode)
{
enum Etc2Mode
{
MODE_INDIVIDUAL = 0,
MODE_DIFFERENTIAL,
MODE_T,
MODE_H,
MODE_PLANAR,
MODE_LAST
};
const int diffOpaqueBit = (int)getBit(src, 33);
const deInt8 selBR = (deInt8)getBits(src, 59, 63); // 5 bits.
const deInt8 selBG = (deInt8)getBits(src, 51, 55);
const deInt8 selBB = (deInt8)getBits(src, 43, 47);
const deInt8 selDR = extendSigned3To8((deUint8)getBits(src, 56, 58)); // 3 bits.
const deInt8 selDG = extendSigned3To8((deUint8)getBits(src, 48, 50));
const deInt8 selDB = extendSigned3To8((deUint8)getBits(src, 40, 42));
Etc2Mode mode;
if (!alphaMode && diffOpaqueBit == 0)
mode = MODE_INDIVIDUAL;
else if (!de::inRange(selBR + selDR, 0, 31))
mode = MODE_T;
else if (!de::inRange(selBG + selDG, 0, 31))
mode = MODE_H;
else if (!de::inRange(selBB + selDB, 0, 31))
mode = MODE_PLANAR;
else
mode = MODE_DIFFERENTIAL;
if (mode == MODE_INDIVIDUAL || mode == MODE_DIFFERENTIAL)
{
// Individual and differential modes have some steps in common, handle them here.
static const int modifierTable[8][4] =
{
// 00 01 10 11
{ 2, 8, -2, -8 },
{ 5, 17, -5, -17 },
{ 9, 29, -9, -29 },
{ 13, 42, -13, -42 },
{ 18, 60, -18, -60 },
{ 24, 80, -24, -80 },
{ 33, 106, -33, -106 },
{ 47, 183, -47, -183 }
};
const int flipBit = (int)getBit(src, 32);
const deUint32 table[2] = { getBits(src, 37, 39), getBits(src, 34, 36) };
deUint8 baseR[2];
deUint8 baseG[2];
deUint8 baseB[2];
if (mode == MODE_INDIVIDUAL)
{
// Individual mode, initial values.
baseR[0] = extend4To8((deUint8)getBits(src, 60, 63));
baseR[1] = extend4To8((deUint8)getBits(src, 56, 59));
baseG[0] = extend4To8((deUint8)getBits(src, 52, 55));
baseG[1] = extend4To8((deUint8)getBits(src, 48, 51));
baseB[0] = extend4To8((deUint8)getBits(src, 44, 47));
baseB[1] = extend4To8((deUint8)getBits(src, 40, 43));
}
else
{
// Differential mode, initial values.
baseR[0] = extend5To8(selBR);
baseG[0] = extend5To8(selBG);
baseB[0] = extend5To8(selBB);
baseR[1] = extend5To8((deUint8)(selBR + selDR));
baseG[1] = extend5To8((deUint8)(selBG + selDG));
baseB[1] = extend5To8((deUint8)(selBB + selDB));
}
// Write final pixels for individual or differential mode.
for (int pixelNdx = 0; pixelNdx < ETC2_BLOCK_HEIGHT*ETC2_BLOCK_WIDTH; pixelNdx++)
{
const int x = pixelNdx / ETC2_BLOCK_HEIGHT;
const int y = pixelNdx % ETC2_BLOCK_HEIGHT;
const int dstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8;
const int subBlock = ((flipBit ? y : x) >= 2) ? 1 : 0;
const deUint32 tableNdx = table[subBlock];
const deUint32 modifierNdx = (getBit(src, 16+pixelNdx) << 1) | getBit(src, pixelNdx);
const int alphaDstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; // Only needed for PUNCHTHROUGH version.
// If doing PUNCHTHROUGH version (alphaMode), opaque bit may affect colors.
if (alphaMode && diffOpaqueBit == 0 && modifierNdx == 2)
{
dst[dstOffset+0] = 0;
dst[dstOffset+1] = 0;
dst[dstOffset+2] = 0;
alphaDst[alphaDstOffset] = 0;
}
else
{
int modifier;
// PUNCHTHROUGH version and opaque bit may also affect modifiers.
if (alphaMode && diffOpaqueBit == 0 && (modifierNdx == 0 || modifierNdx == 2))
modifier = 0;
else
modifier = modifierTable[tableNdx][modifierNdx];
dst[dstOffset+0] = (deUint8)deClamp32((int)baseR[subBlock] + modifier, 0, 255);
dst[dstOffset+1] = (deUint8)deClamp32((int)baseG[subBlock] + modifier, 0, 255);
dst[dstOffset+2] = (deUint8)deClamp32((int)baseB[subBlock] + modifier, 0, 255);
if (alphaMode)
alphaDst[alphaDstOffset] = 255;
}
}
}
else if (mode == MODE_T || mode == MODE_H)
{
// T and H modes have some steps in common, handle them here.
static const int distTable[8] = { 3, 6, 11, 16, 23, 32, 41, 64 };
deUint8 paintR[4];
deUint8 paintG[4];
deUint8 paintB[4];
if (mode == MODE_T)
{
// T mode, calculate paint values.
const deUint8 R1a = (deUint8)getBits(src, 59, 60);
const deUint8 R1b = (deUint8)getBits(src, 56, 57);
const deUint8 G1 = (deUint8)getBits(src, 52, 55);
const deUint8 B1 = (deUint8)getBits(src, 48, 51);
const deUint8 R2 = (deUint8)getBits(src, 44, 47);
const deUint8 G2 = (deUint8)getBits(src, 40, 43);
const deUint8 B2 = (deUint8)getBits(src, 36, 39);
const deUint32 distNdx = (getBits(src, 34, 35) << 1) | getBit(src, 32);
const int dist = distTable[distNdx];
paintR[0] = extend4To8((deUint8)((R1a << 2) | R1b));
paintG[0] = extend4To8(G1);
paintB[0] = extend4To8(B1);
paintR[2] = extend4To8(R2);
paintG[2] = extend4To8(G2);
paintB[2] = extend4To8(B2);
paintR[1] = (deUint8)deClamp32((int)paintR[2] + dist, 0, 255);
paintG[1] = (deUint8)deClamp32((int)paintG[2] + dist, 0, 255);
paintB[1] = (deUint8)deClamp32((int)paintB[2] + dist, 0, 255);
paintR[3] = (deUint8)deClamp32((int)paintR[2] - dist, 0, 255);
paintG[3] = (deUint8)deClamp32((int)paintG[2] - dist, 0, 255);
paintB[3] = (deUint8)deClamp32((int)paintB[2] - dist, 0, 255);
}
else
{
// H mode, calculate paint values.
const deUint8 R1 = (deUint8)getBits(src, 59, 62);
const deUint8 G1a = (deUint8)getBits(src, 56, 58);
const deUint8 G1b = (deUint8)getBit(src, 52);
const deUint8 B1a = (deUint8)getBit(src, 51);
const deUint8 B1b = (deUint8)getBits(src, 47, 49);
const deUint8 R2 = (deUint8)getBits(src, 43, 46);
const deUint8 G2 = (deUint8)getBits(src, 39, 42);
const deUint8 B2 = (deUint8)getBits(src, 35, 38);
deUint8 baseR[2];
deUint8 baseG[2];
deUint8 baseB[2];
deUint32 baseValue[2];
deUint32 distNdx;
int dist;
baseR[0] = extend4To8(R1);
baseG[0] = extend4To8((deUint8)((G1a << 1) | G1b));
baseB[0] = extend4To8((deUint8)((B1a << 3) | B1b));
baseR[1] = extend4To8(R2);
baseG[1] = extend4To8(G2);
baseB[1] = extend4To8(B2);
baseValue[0] = (((deUint32)baseR[0]) << 16) | (((deUint32)baseG[0]) << 8) | baseB[0];
baseValue[1] = (((deUint32)baseR[1]) << 16) | (((deUint32)baseG[1]) << 8) | baseB[1];
distNdx = (getBit(src, 34) << 2) | (getBit(src, 32) << 1) | (deUint32)(baseValue[0] >= baseValue[1]);
dist = distTable[distNdx];
paintR[0] = (deUint8)deClamp32((int)baseR[0] + dist, 0, 255);
paintG[0] = (deUint8)deClamp32((int)baseG[0] + dist, 0, 255);
paintB[0] = (deUint8)deClamp32((int)baseB[0] + dist, 0, 255);
paintR[1] = (deUint8)deClamp32((int)baseR[0] - dist, 0, 255);
paintG[1] = (deUint8)deClamp32((int)baseG[0] - dist, 0, 255);
paintB[1] = (deUint8)deClamp32((int)baseB[0] - dist, 0, 255);
paintR[2] = (deUint8)deClamp32((int)baseR[1] + dist, 0, 255);
paintG[2] = (deUint8)deClamp32((int)baseG[1] + dist, 0, 255);
paintB[2] = (deUint8)deClamp32((int)baseB[1] + dist, 0, 255);
paintR[3] = (deUint8)deClamp32((int)baseR[1] - dist, 0, 255);
paintG[3] = (deUint8)deClamp32((int)baseG[1] - dist, 0, 255);
paintB[3] = (deUint8)deClamp32((int)baseB[1] - dist, 0, 255);
}
// Write final pixels for T or H mode.
for (int pixelNdx = 0; pixelNdx < ETC2_BLOCK_HEIGHT*ETC2_BLOCK_WIDTH; pixelNdx++)
{
const int x = pixelNdx / ETC2_BLOCK_HEIGHT;
const int y = pixelNdx % ETC2_BLOCK_HEIGHT;
const int dstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8;
const deUint32 paintNdx = (getBit(src, 16+pixelNdx) << 1) | getBit(src, pixelNdx);
const int alphaDstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; // Only needed for PUNCHTHROUGH version.
if (alphaMode && diffOpaqueBit == 0 && paintNdx == 2)
{
dst[dstOffset+0] = 0;
dst[dstOffset+1] = 0;
dst[dstOffset+2] = 0;
alphaDst[alphaDstOffset] = 0;
}
else
{
dst[dstOffset+0] = (deUint8)deClamp32((int)paintR[paintNdx], 0, 255);
dst[dstOffset+1] = (deUint8)deClamp32((int)paintG[paintNdx], 0, 255);
dst[dstOffset+2] = (deUint8)deClamp32((int)paintB[paintNdx], 0, 255);
if (alphaMode)
alphaDst[alphaDstOffset] = 255;
}
}
}
else
{
// Planar mode.
const deUint8 GO1 = (deUint8)getBit(src, 56);
const deUint8 GO2 = (deUint8)getBits(src, 49, 54);
const deUint8 BO1 = (deUint8)getBit(src, 48);
const deUint8 BO2 = (deUint8)getBits(src, 43, 44);
const deUint8 BO3 = (deUint8)getBits(src, 39, 41);
const deUint8 RH1 = (deUint8)getBits(src, 34, 38);
const deUint8 RH2 = (deUint8)getBit(src, 32);
const deUint8 RO = extend6To8((deUint8)getBits(src, 57, 62));
const deUint8 GO = extend7To8((deUint8)((GO1 << 6) | GO2));
const deUint8 BO = extend6To8((deUint8)((BO1 << 5) | (BO2 << 3) | BO3));
const deUint8 RH = extend6To8((deUint8)((RH1 << 1) | RH2));
const deUint8 GH = extend7To8((deUint8)getBits(src, 25, 31));
const deUint8 BH = extend6To8((deUint8)getBits(src, 19, 24));
const deUint8 RV = extend6To8((deUint8)getBits(src, 13, 18));
const deUint8 GV = extend7To8((deUint8)getBits(src, 6, 12));
const deUint8 BV = extend6To8((deUint8)getBits(src, 0, 5));
// Write final pixels for planar mode.
for (int y = 0; y < 4; y++)
{
for (int x = 0; x < 4; x++)
{
const int dstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8;
const int unclampedR = (x * ((int)RH-(int)RO) + y * ((int)RV-(int)RO) + 4*(int)RO + 2) >> 2;
const int unclampedG = (x * ((int)GH-(int)GO) + y * ((int)GV-(int)GO) + 4*(int)GO + 2) >> 2;
const int unclampedB = (x * ((int)BH-(int)BO) + y * ((int)BV-(int)BO) + 4*(int)BO + 2) >> 2;
const int alphaDstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_A8; // Only needed for PUNCHTHROUGH version.
dst[dstOffset+0] = (deUint8)deClamp32(unclampedR, 0, 255);
dst[dstOffset+1] = (deUint8)deClamp32(unclampedG, 0, 255);
dst[dstOffset+2] = (deUint8)deClamp32(unclampedB, 0, 255);
if (alphaMode)
alphaDst[alphaDstOffset] = 255;
}
}
}
}
void decompressEAC8Block (deUint8 dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_A8], deUint64 src)
{
static const int modifierTable[16][8] =
{
{-3, -6, -9, -15, 2, 5, 8, 14},
{-3, -7, -10, -13, 2, 6, 9, 12},
{-2, -5, -8, -13, 1, 4, 7, 12},
{-2, -4, -6, -13, 1, 3, 5, 12},
{-3, -6, -8, -12, 2, 5, 7, 11},
{-3, -7, -9, -11, 2, 6, 8, 10},
{-4, -7, -8, -11, 3, 6, 7, 10},
{-3, -5, -8, -11, 2, 4, 7, 10},
{-2, -6, -8, -10, 1, 5, 7, 9},
{-2, -5, -8, -10, 1, 4, 7, 9},
{-2, -4, -8, -10, 1, 3, 7, 9},
{-2, -5, -7, -10, 1, 4, 6, 9},
{-3, -4, -7, -10, 2, 3, 6, 9},
{-1, -2, -3, -10, 0, 1, 2, 9},
{-4, -6, -8, -9, 3, 5, 7, 8},
{-3, -5, -7, -9, 2, 4, 6, 8}
};
const deUint8 baseCodeword = (deUint8)getBits(src, 56, 63);
const deUint8 multiplier = (deUint8)getBits(src, 52, 55);
const deUint32 tableNdx = getBits(src, 48, 51);
for (int pixelNdx = 0; pixelNdx < ETC2_BLOCK_HEIGHT*ETC2_BLOCK_WIDTH; pixelNdx++)
{
const int x = pixelNdx / ETC2_BLOCK_HEIGHT;
const int y = pixelNdx % ETC2_BLOCK_HEIGHT;
const int dstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_A8;
const int pixelBitNdx = 45 - 3*pixelNdx;
const deUint32 modifierNdx = (getBit(src, pixelBitNdx + 2) << 2) | (getBit(src, pixelBitNdx + 1) << 1) | getBit(src, pixelBitNdx);
const int modifier = modifierTable[tableNdx][modifierNdx];
dst[dstOffset] = (deUint8)deClamp32((int)baseCodeword + (int)multiplier*modifier, 0, 255);
}
}
void decompressEAC11Block (deUint8 dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_R11], deUint64 src, bool signedMode)
{
static const int modifierTable[16][8] =
{
{-3, -6, -9, -15, 2, 5, 8, 14},
{-3, -7, -10, -13, 2, 6, 9, 12},
{-2, -5, -8, -13, 1, 4, 7, 12},
{-2, -4, -6, -13, 1, 3, 5, 12},
{-3, -6, -8, -12, 2, 5, 7, 11},
{-3, -7, -9, -11, 2, 6, 8, 10},
{-4, -7, -8, -11, 3, 6, 7, 10},
{-3, -5, -8, -11, 2, 4, 7, 10},
{-2, -6, -8, -10, 1, 5, 7, 9},
{-2, -5, -8, -10, 1, 4, 7, 9},
{-2, -4, -8, -10, 1, 3, 7, 9},
{-2, -5, -7, -10, 1, 4, 6, 9},
{-3, -4, -7, -10, 2, 3, 6, 9},
{-1, -2, -3, -10, 0, 1, 2, 9},
{-4, -6, -8, -9, 3, 5, 7, 8},
{-3, -5, -7, -9, 2, 4, 6, 8}
};
const deInt32 multiplier = (deInt32)getBits(src, 52, 55);
const deInt32 tableNdx = (deInt32)getBits(src, 48, 51);
deInt32 baseCodeword = (deInt32)getBits(src, 56, 63);
if (signedMode)
{
if (baseCodeword > 127)
baseCodeword -= 256;
if (baseCodeword == -128)
baseCodeword = -127;
}
for (int pixelNdx = 0; pixelNdx < ETC2_BLOCK_HEIGHT*ETC2_BLOCK_WIDTH; pixelNdx++)
{
const int x = pixelNdx / ETC2_BLOCK_HEIGHT;
const int y = pixelNdx % ETC2_BLOCK_HEIGHT;
const int dstOffset = (y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11;
const int pixelBitNdx = 45 - 3*pixelNdx;
const deUint32 modifierNdx = (getBit(src, pixelBitNdx + 2) << 2) | (getBit(src, pixelBitNdx + 1) << 1) | getBit(src, pixelBitNdx);
const int modifier = modifierTable[tableNdx][modifierNdx];
if (signedMode)
{
deInt16 value;
if (multiplier != 0)
value = (deInt16)deClamp32(baseCodeword*8 + multiplier*modifier*8, -1023, 1023);
else
value = (deInt16)deClamp32(baseCodeword*8 + modifier, -1023, 1023);
*((deInt16*)(dst + dstOffset)) = value;
}
else
{
deUint16 value;
if (multiplier != 0)
value = (deUint16)deClamp32(baseCodeword*8 + 4 + multiplier*modifier*8, 0, 2047);
else
value= (deUint16)deClamp32(baseCodeword*8 + 4 + modifier, 0, 2047);
*((deUint16*)(dst + dstOffset)) = value;
}
}
}
} // EtcDecompressInternal
void decompressETC1 (const PixelBufferAccess& dst, const deUint8* src)
{
using namespace EtcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint64 compressedBlock = get64BitBlock(src, 0);
decompressETC1Block(dstPtr, compressedBlock);
}
void decompressETC2 (const PixelBufferAccess& dst, const deUint8* src)
{
using namespace EtcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint64 compressedBlock = get64BitBlock(src, 0);
decompressETC2Block(dstPtr, compressedBlock, NULL, false);
}
void decompressETC2_EAC_RGBA8 (const PixelBufferAccess& dst, const deUint8* src)
{
using namespace EtcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const int dstRowPitch = dst.getRowPitch();
const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8;
const deUint64 compressedBlockAlpha = get128BitBlockStart(src, 0);
const deUint64 compressedBlockRGB = get128BitBlockEnd(src, 0);
deUint8 uncompressedBlockAlpha[ETC2_UNCOMPRESSED_BLOCK_SIZE_A8];
deUint8 uncompressedBlockRGB[ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8];
// Decompress.
decompressETC2Block(uncompressedBlockRGB, compressedBlockRGB, NULL, false);
decompressEAC8Block(uncompressedBlockAlpha, compressedBlockAlpha);
// Write to dst.
for (int y = 0; y < (int)ETC2_BLOCK_HEIGHT; y++)
{
for (int x = 0; x < (int)ETC2_BLOCK_WIDTH; x++)
{
const deUint8* const srcPixelRGB = &uncompressedBlockRGB[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8];
const deUint8* const srcPixelAlpha = &uncompressedBlockAlpha[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_A8];
deUint8* const dstPixel = dstPtr + y*dstRowPitch + x*dstPixelSize;
DE_STATIC_ASSERT(ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 == 4);
dstPixel[0] = srcPixelRGB[0];
dstPixel[1] = srcPixelRGB[1];
dstPixel[2] = srcPixelRGB[2];
dstPixel[3] = srcPixelAlpha[0];
}
}
}
void decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1 (const PixelBufferAccess& dst, const deUint8* src)
{
using namespace EtcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const int dstRowPitch = dst.getRowPitch();
const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8;
const deUint64 compressedBlockRGBA = get64BitBlock(src, 0);
deUint8 uncompressedBlockRGB[ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8];
deUint8 uncompressedBlockAlpha[ETC2_UNCOMPRESSED_BLOCK_SIZE_A8];
// Decompress.
decompressETC2Block(uncompressedBlockRGB, compressedBlockRGBA, uncompressedBlockAlpha, DE_TRUE);
// Write to dst.
for (int y = 0; y < (int)ETC2_BLOCK_HEIGHT; y++)
{
for (int x = 0; x < (int)ETC2_BLOCK_WIDTH; x++)
{
const deUint8* const srcPixel = &uncompressedBlockRGB[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8];
const deUint8* const srcPixelAlpha = &uncompressedBlockAlpha[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_A8];
deUint8* const dstPixel = dstPtr + y*dstRowPitch + x*dstPixelSize;
DE_STATIC_ASSERT(ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8 == 4);
dstPixel[0] = srcPixel[0];
dstPixel[1] = srcPixel[1];
dstPixel[2] = srcPixel[2];
dstPixel[3] = srcPixelAlpha[0];
}
}
}
void decompressEAC_R11 (const PixelBufferAccess& dst, const deUint8* src, bool signedMode)
{
using namespace EtcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const int dstRowPitch = dst.getRowPitch();
const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_R11;
const deUint64 compressedBlock = get64BitBlock(src, 0);
deUint8 uncompressedBlock[ETC2_UNCOMPRESSED_BLOCK_SIZE_R11];
// Decompress.
decompressEAC11Block(uncompressedBlock, compressedBlock, signedMode);
// Write to dst.
for (int y = 0; y < (int)ETC2_BLOCK_HEIGHT; y++)
{
for (int x = 0; x < (int)ETC2_BLOCK_WIDTH; x++)
{
DE_STATIC_ASSERT(ETC2_UNCOMPRESSED_PIXEL_SIZE_R11 == 2);
if (signedMode)
{
const deInt16* const srcPixel = (deInt16*)&uncompressedBlock[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11];
deInt16* const dstPixel = (deInt16*)(dstPtr + y*dstRowPitch + x*dstPixelSize);
dstPixel[0] = extend11To16WithSign(srcPixel[0]);
}
else
{
const deUint16* const srcPixel = (deUint16*)&uncompressedBlock[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11];
deUint16* const dstPixel = (deUint16*)(dstPtr + y*dstRowPitch + x*dstPixelSize);
dstPixel[0] = extend11To16(srcPixel[0]);
}
}
}
}
void decompressEAC_RG11 (const PixelBufferAccess& dst, const deUint8* src, bool signedMode)
{
using namespace EtcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const int dstRowPitch = dst.getRowPitch();
const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11;
const deUint64 compressedBlockR = get128BitBlockStart(src, 0);
const deUint64 compressedBlockG = get128BitBlockEnd(src, 0);
deUint8 uncompressedBlockR[ETC2_UNCOMPRESSED_BLOCK_SIZE_R11];
deUint8 uncompressedBlockG[ETC2_UNCOMPRESSED_BLOCK_SIZE_R11];
// Decompress.
decompressEAC11Block(uncompressedBlockR, compressedBlockR, signedMode);
decompressEAC11Block(uncompressedBlockG, compressedBlockG, signedMode);
// Write to dst.
for (int y = 0; y < (int)ETC2_BLOCK_HEIGHT; y++)
{
for (int x = 0; x < (int)ETC2_BLOCK_WIDTH; x++)
{
DE_STATIC_ASSERT(ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11 == 4);
if (signedMode)
{
const deInt16* const srcPixelR = (deInt16*)&uncompressedBlockR[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11];
const deInt16* const srcPixelG = (deInt16*)&uncompressedBlockG[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11];
deInt16* const dstPixel = (deInt16*)(dstPtr + y*dstRowPitch + x*dstPixelSize);
dstPixel[0] = extend11To16WithSign(srcPixelR[0]);
dstPixel[1] = extend11To16WithSign(srcPixelG[0]);
}
else
{
const deUint16* const srcPixelR = (deUint16*)&uncompressedBlockR[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11];
const deUint16* const srcPixelG = (deUint16*)&uncompressedBlockG[(y*ETC2_BLOCK_WIDTH + x)*ETC2_UNCOMPRESSED_PIXEL_SIZE_R11];
deUint16* const dstPixel = (deUint16*)(dstPtr + y*dstRowPitch + x*dstPixelSize);
dstPixel[0] = extend11To16(srcPixelR[0]);
dstPixel[1] = extend11To16(srcPixelG[0]);
}
}
}
}
namespace BcDecompressInternal
{
enum
{
BC_BLOCK_WIDTH = 4,
BC_BLOCK_HEIGHT = 4
};
static const deUint8 epBits[14] = { 10, 7, 11, 11, 11, 9, 8, 8, 8, 6, 10, 11, 12, 16 };
static const deUint8 partitions2[64][16] =
{
{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 },
{ 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1 },
{ 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1 },
{ 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1 },
{ 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1 },
{ 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0 },
{ 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0 },
{ 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1 },
{ 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0 },
{ 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0 },
{ 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0 },
{ 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0 },
{ 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 },
{ 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0 },
{ 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0 },
{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1 },
{ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1 },
{ 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0 },
{ 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0 },
{ 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0 },
{ 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0 },
{ 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1 },
{ 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1 },
{ 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0 },
{ 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0 },
{ 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0 },
{ 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0 },
{ 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0 },
{ 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1 },
{ 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1 },
{ 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0 },
{ 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0 },
{ 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1 },
{ 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 1 },
{ 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0 },
{ 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0 },
{ 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1 },
{ 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1 },
{ 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1 },
{ 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1 },
{ 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1 },
{ 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0 },
{ 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1 }
};
static const deUint8 partitions3[64][16] =
{
{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 1, 2, 2, 2, 2 },
{ 0, 0, 0, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 2, 1 },
{ 0, 0, 0, 0, 2, 0, 0, 1, 2, 2, 1, 1, 2, 2, 1, 1 },
{ 0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 1, 0, 1, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2 },
{ 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2 },
{ 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1 },
{ 0, 0, 1, 1, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2 },
{ 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2 },
{ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2 },
{ 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2, 0, 1, 1, 2 },
{ 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2, 0, 1, 2, 2 },
{ 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2, 1, 2, 2, 2 },
{ 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0, 2, 2, 2, 0 },
{ 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 2, 1, 1, 2, 2 },
{ 0, 1, 1, 1, 0, 0, 1, 1, 2, 0, 0, 1, 2, 2, 0, 0 },
{ 0, 0, 0, 0, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2 },
{ 0, 0, 2, 2, 0, 0, 2, 2, 0, 0, 2, 2, 1, 1, 1, 1 },
{ 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2, 0, 2, 2, 2 },
{ 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 1, 2, 2, 2, 1 },
{ 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2 },
{ 0, 0, 0, 0, 1, 1, 0, 0, 2, 2, 1, 0, 2, 2, 1, 0 },
{ 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1, 0, 0, 0, 0 },
{ 0, 0, 1, 2, 0, 0, 1, 2, 1, 1, 2, 2, 2, 2, 2, 2 },
{ 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0 },
{ 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1 },
{ 0, 0, 2, 2, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 2, 2 },
{ 0, 1, 1, 0, 0, 1, 1, 0, 2, 0, 0, 2, 2, 2, 2, 2 },
{ 0, 0, 1, 1, 0, 1, 2, 2, 0, 1, 2, 2, 0, 0, 1, 1 },
{ 0, 0, 0, 0, 2, 0, 0, 0, 2, 2, 1, 1, 2, 2, 2, 1 },
{ 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 2, 2, 2 },
{ 0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 1, 2, 0, 0, 1, 1 },
{ 0, 0, 1, 1, 0, 0, 1, 2, 0, 0, 2, 2, 0, 2, 2, 2 },
{ 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0, 0, 1, 2, 0 },
{ 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0 },
{ 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0 },
{ 0, 1, 2, 0, 2, 0, 1, 2, 1, 2, 0, 1, 0, 1, 2, 0 },
{ 0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2, 0, 0, 1, 1 },
{ 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 0, 0, 0, 0, 1, 1 },
{ 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1 },
{ 0, 0, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2, 1, 1, 2, 2 },
{ 0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 2, 2, 0, 0, 1, 1 },
{ 0, 2, 2, 0, 1, 2, 2, 1, 0, 2, 2, 0, 1, 2, 2, 1 },
{ 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 0, 1 },
{ 0, 0, 0, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1 },
{ 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 2, 2, 2, 2 },
{ 0, 2, 2, 2, 0, 1, 1, 1, 0, 2, 2, 2, 0, 1, 1, 1 },
{ 0, 0, 0, 2, 1, 1, 1, 2, 0, 0, 0, 2, 1, 1, 1, 2 },
{ 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2 },
{ 0, 2, 2, 2, 0, 1, 1, 1, 0, 1, 1, 1, 0, 2, 2, 2 },
{ 0, 0, 0, 2, 1, 1, 1, 2, 1, 1, 1, 2, 0, 0, 0, 2 },
{ 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2, 2, 1, 1, 2 },
{ 0, 1, 1, 0, 0, 1, 1, 0, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 0, 0, 2, 2, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 2, 2 },
{ 0, 0, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 0, 0, 2, 2 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 1, 2 },
{ 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 1 },
{ 0, 2, 2, 2, 1, 2, 2, 2, 0, 2, 2, 2, 1, 2, 2, 2 },
{ 0, 1, 0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2 },
{ 0, 1, 1, 1, 2, 0, 1, 1, 2, 2, 0, 1, 2, 2, 2, 0 }
};
static const deUint8 anchorIndicesSecondSubset2[64] = { 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 2, 8, 2, 2, 8, 8, 15, 2, 8, 2, 2, 8, 8, 2, 2,
15, 15, 6, 8, 2, 8, 15, 15, 2, 8, 2, 2, 2, 15, 15, 6, 6, 2, 6, 8, 15, 15, 2, 2, 15, 15, 15, 15, 15, 2, 2, 15 };
static const deUint8 anchorIndicesSecondSubset3[64] = { 3, 3, 15, 15, 8, 3, 15, 15, 8, 8, 6, 6, 6, 5, 3, 3, 3, 3, 8, 15, 3, 3, 6, 10, 5, 8, 8, 6, 8, 5, 15, 15,
8, 15, 3, 5, 6, 10, 8, 15, 15, 3, 15, 5, 15, 15, 15, 15, 3, 15, 5, 5, 5, 8, 5, 10, 5, 10, 8, 13, 15, 12, 3, 3 };
static const deUint8 anchorIndicesThirdSubset[64] = { 15, 8, 8, 3, 15, 15, 3, 8, 15, 15, 15, 15, 15, 15, 15, 8, 15, 8, 15, 3, 15, 8, 15, 8, 3, 15, 6, 10, 15, 15, 10, 8,
15, 3, 15, 10, 10, 8, 9, 10, 6, 15, 8, 15, 3, 6, 6, 8, 15, 3, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 3, 15, 15, 8 };
static const deUint16 weights2[4] = { 0, 21, 43, 64 };
static const deUint16 weights3[8] = { 0, 9, 18, 27, 37, 46, 55, 64 };
static const deUint16 weights4[16] = { 0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64 };
inline float uint8ToFloat (deUint8 src)
{
return ((float)src / 255.0f);
}
inline float int8ToFloat (deInt8 src)
{
return ((float)src / 128.0f);
}
inline deUint32 bgr16torgba32 (deUint16 src)
{
const deUint32 src32 = src;
const deUint8 b5 = (src32 & 0x1f);
const deUint8 g6 = (src32 >> 5) & 0x3f;
const deUint8 r5 = (src32 >> 11) & 0x1f;
const deUint32 a8 = 0xff;
const deUint32 b8 = extend5To8(b5);
const deUint32 g8 = extend6To8(g6);
const deUint32 r8 = extend5To8(r5);
return (r8 | (g8 <<8) | (b8 << 16) | (a8 << 24));
}
// Interpolates color = 1/3 * c0 + 2/3 * c1
inline deUint32 interpolateColor (deUint32 c0, deUint32 c1)
{
const deUint32 r0 = c0 & 0xff;
const deUint32 g0 = (c0 >> 8) & 0xff;
const deUint32 b0 = (c0 >> 16) & 0xff;
const deUint32 a0 = (c0 >> 24) & 0xff;
const deUint32 r1 = c1 & 0xff;
const deUint32 g1 = (c1 >> 8) & 0xff;
const deUint32 b1 = (c1 >> 16) & 0xff;
const deUint32 a1 = (c1 >> 24) & 0xff;
const deUint32 r = (r0 + (r1 << 1)) / 3;
const deUint32 g = (g0 + (g1 << 1)) / 3;
const deUint32 b = (b0 + (b1 << 1)) / 3;
const deUint32 a = (a0 + (a1 << 1)) / 3;
return (r | (g << 8) | (b << 16) | (a << 24));
}
// Average of two colors
inline deUint32 averageColor (deUint32 c0, deUint32 c1)
{
const deUint32 r0 = c0 & 0xff;
const deUint32 g0 = (c0 >> 8) & 0xff;
const deUint32 b0 = (c0 >> 16) & 0xff;
const deUint32 a0 = (c0 >> 24) & 0xff;
const deUint32 r1 = c1 & 0xff;
const deUint32 g1 = (c1 >> 8) & 0xff;
const deUint32 b1 = (c1 >> 16) & 0xff;
const deUint32 a1 = (c1 >> 24) & 0xff;
const deUint32 r = (r0 + r1) >> 1;
const deUint32 g = (g0 + g1) >> 1;
const deUint32 b = (b0 + b1) >> 1;
const deUint32 a = (a0 + a1) >> 1;
return (r | (g << 8) | (b << 16) | (a << 24));
}
inline deInt8 extractModeBc6 (deUint8 src)
{
// Catch illegal modes
switch(src & 0x1f)
{
case 0x13:
case 0x17:
case 0x1b:
case 0x1f:
return -1;
};
switch (src & 0x3)
{
case 0: return 0;
case 1: return 1;
case 2: return (deInt8)(2 + ((src >> 2) & 0x7));
case 3: return (deInt8)(10 + ((src >> 2) & 0x7));
};
return -1;
}
inline deInt8 extractModeBc7 (deUint8 src)
{
for (deInt8 i = 0; i < 8; i++)
if (src & (1 << i))
return i;
return -1;
}
inline deUint64 get64BitBlockLE (const deUint8* src, int blockNdx)
{
// Same as get64BitBlock, but little-endian.
deUint64 block = 0;
for (int i = 0; i < 8; i++)
block |= (deUint64)(src[blockNdx*8+i]) << (8ull*i);
return block;
}
inline deUint32 getBits128 (deUint64 low, deUint64 high, deUint32 first, deUint32 last)
{
const deUint64 d[2] = { low, high };
const bool reverse = first > last;
deUint32 ret = 0;
if (reverse)
{
const deUint32 tmp = first;
first = last;
last = tmp;
}
const int elementFirst = first / 64;
const int elementLast = last / 64;
if (elementFirst == elementLast)
{
// Bits contained in one of the 64bit elements
const deUint32 shift = first % 64;
const deUint32 len = last - first + 1;
const deUint32 mask = (1 << len) - 1;
ret = (deUint32)((d[elementFirst] >> shift) & mask);
}
else
{
// Bits contained in both of the 64bit elements
DE_ASSERT(last > 63);
DE_ASSERT(first < 64);
const deUint32 len0 = 64 - first;
const deUint32 mask0 = (1 << len0) - 1;
const deUint32 data0 = (deUint32)(low >> first) & mask0;
const deUint32 len1 = last - 63;
const deUint32 mask1 = (1 << len1) - 1;
const deUint32 data1 = (deUint32)(high & mask1);
ret = (deUint32)((data1 << len0) | data0);
}
if (reverse)
{
const deUint32 len = last - first + 1;
const deUint32 orig = ret;
ret = 0;
for (deUint32 i = 0; i < len; i++)
{
ret |= ((orig >> (len - 1 - i)) & 1) << i;
}
}
return ret;
}
inline deInt32 signExtend (deInt32 value, deInt32 srcBits, deInt32 dstBits)
{
deUint32 sign = value & (1 << (srcBits - 1));
if (!sign) return value;
deInt32 dstMask = (deInt32)(((deUint64)1 << dstBits) - 1);
deInt32 extendedBits = 0xffffffff << srcBits;
return (value | extendedBits) & dstMask;
}
inline deInt32 unquantize (deInt32 x, int mode, bool hasSign)
{
if (hasSign)
{
bool s = false;
if (epBits[mode] >= 16) return x;
if (x < 0)
{
s = true;
x = -x;
}
if (x == 0)
x = 0;
else if (x >= (((deInt32)1 << (epBits[mode] - 1)) - 1))
x = 0x7fff;
else
x = (((deInt32)x << 15) + 0x4000) >> (epBits[mode] - 1);
if (s)
x = -x;
return x;
}
else
{
if (epBits[mode] >= 15)
return x;
else if (x == 0)
return 0;
else if (x == (((deInt32)1 << epBits[mode]) - 1))
return 0xffff;
else
return ((((deInt32)x << 15) + 0x4000) >> (epBits[mode] - 1));
}
}
inline deInt32 interpolate (deInt32 a, deInt32 b, deUint32 index, deUint32 indexPrecision)
{
const deUint16* weights[] = {weights2, weights3, weights4};
const deUint16* weight = weights[indexPrecision-2];
DE_ASSERT(indexPrecision >= 2 && indexPrecision <= 4);
return (((64 - weight[index]) * a + weight[index] * b + 32) >> 6);
}
inline deInt16 finishUnquantize (deInt32 x, bool hasSign)
{
if (hasSign)
{
if (x < 0)
x = -(((-x) * 31) >> 5);
else
x = (x * 31) >> 5;
if (x < 0)
x = (-x) | 0x8000;
}
else
{
x = (x * 31) / 64;
}
return (deInt16)x;
}
} // BcDecompressInternal
void decompressBc1 (const PixelBufferAccess& dst, const deUint8* src, bool hasAlpha)
{
using namespace BcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint32 dstRowPitch = dst.getRowPitch();
const deUint32 dstPixelSize = 4;
const deUint16 color0_16 = ((deUint16*)src)[0];
const deUint16 color1_16 = ((deUint16*)src)[1];
const deUint32 color0 = bgr16torgba32(color0_16);
const deUint32 color1 = bgr16torgba32(color1_16);
const deUint8* const indices8 = &src[4];
const bool alphaMode = color1_16 > color0_16;
const deInt32 indices[16] =
{
(indices8[0] >> 0) & 0x3,
(indices8[0] >> 2) & 0x3,
(indices8[0] >> 4) & 0x3,
(indices8[0] >> 6) & 0x3,
(indices8[1] >> 0) & 0x3,
(indices8[1] >> 2) & 0x3,
(indices8[1] >> 4) & 0x3,
(indices8[1] >> 6) & 0x3,
(indices8[2] >> 0) & 0x3,
(indices8[2] >> 2) & 0x3,
(indices8[2] >> 4) & 0x3,
(indices8[2] >> 6) & 0x3,
(indices8[3] >> 0) & 0x3,
(indices8[3] >> 2) & 0x3,
(indices8[3] >> 4) & 0x3,
(indices8[3] >> 6) & 0x3
};
const deUint32 colors[4] =
{
color0,
color1,
alphaMode ? averageColor(color0, color1) : interpolateColor(color1, color0),
alphaMode ? (hasAlpha ? 0 : 0xff000000) : interpolateColor(color0, color1)
};
for (deUint32 y = 0; y < (deUint32)BC_BLOCK_HEIGHT; y++)
{
for (deUint32 x = 0; x < (deUint32)BC_BLOCK_WIDTH; x++)
{
deUint32* const dstPixel = (deUint32*)(dstPtr + y * dstRowPitch + x * dstPixelSize);
*dstPixel = colors[indices[y * BC_BLOCK_WIDTH + x]];
}
}
}
void decompressBc2 (const PixelBufferAccess& dst, const deUint8* src)
{
using namespace BcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint32 dstRowPitch = dst.getRowPitch();
const deUint32 dstPixelSize = 4;
const deUint16 color0_16 = ((deUint16*)src)[4];
const deUint16 color1_16 = ((deUint16*)src)[5];
const deUint32 color0 = bgr16torgba32(color0_16);
const deUint32 color1 = bgr16torgba32(color1_16);
const deUint8* const indices8 = &src[12];
const deUint8* const alphas8 = src;
const deInt32 indices[16] =
{
(indices8[0] >> 0) & 0x3,
(indices8[0] >> 2) & 0x3,
(indices8[0] >> 4) & 0x3,
(indices8[0] >> 6) & 0x3,
(indices8[1] >> 0) & 0x3,
(indices8[1] >> 2) & 0x3,
(indices8[1] >> 4) & 0x3,
(indices8[1] >> 6) & 0x3,
(indices8[2] >> 0) & 0x3,
(indices8[2] >> 2) & 0x3,
(indices8[2] >> 4) & 0x3,
(indices8[2] >> 6) & 0x3,
(indices8[3] >> 0) & 0x3,
(indices8[3] >> 2) & 0x3,
(indices8[3] >> 4) & 0x3,
(indices8[3] >> 6) & 0x3
};
const deInt32 alphas[16] =
{
extend4To8(((alphas8[0] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[0] >> 4) & 0xf)) << 24,
extend4To8(((alphas8[1] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[1] >> 4) & 0xf)) << 24,
extend4To8(((alphas8[2] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[2] >> 4) & 0xf)) << 24,
extend4To8(((alphas8[3] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[3] >> 4) & 0xf)) << 24,
extend4To8(((alphas8[4] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[4] >> 4) & 0xf)) << 24,
extend4To8(((alphas8[5] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[5] >> 4) & 0xf)) << 24,
extend4To8(((alphas8[6] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[6] >> 4) & 0xf)) << 24,
extend4To8(((alphas8[7] >> 0) & 0xf)) << 24,
extend4To8(((alphas8[7] >> 4) & 0xf)) << 24
};
const deUint32 colors[4] =
{
color0,
color1,
interpolateColor(color1, color0),
interpolateColor(color0, color1)
};
for (deUint32 y = 0; y < (deUint32)BC_BLOCK_HEIGHT; y++)
{
for (deUint32 x = 0; x < (deUint32)BC_BLOCK_WIDTH; x++)
{
deUint32* const dstPixel = (deUint32*)(dstPtr + y * dstRowPitch + x * dstPixelSize);
*dstPixel = (colors[indices[y * BC_BLOCK_WIDTH + x]] & 0x00ffffff) | alphas[y * BC_BLOCK_WIDTH + x];
}
}
}
void decompressBc3 (const PixelBufferAccess& dst, const deUint8* src)
{
using namespace BcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint32 dstRowPitch = dst.getRowPitch();
const deUint32 dstPixelSize = 4;
const deUint8 alpha0 = src[0];
const deUint8 alpha1 = src[1];
const deUint16 color0_16 = ((deUint16*)src)[4];
const deUint16 color1_16 = ((deUint16*)src)[5];
const deUint32 color0 = bgr16torgba32(color0_16);
const deUint32 color1 = bgr16torgba32(color1_16);
const deUint8* const indices8 = &src[12];
const deUint64 alphaBits = get64BitBlockLE(src, 0) >> 16;
deUint32 alphas[8];
const deInt32 indices[16] =
{
(indices8[0] >> 0) & 0x3,
(indices8[0] >> 2) & 0x3,
(indices8[0] >> 4) & 0x3,
(indices8[0] >> 6) & 0x3,
(indices8[1] >> 0) & 0x3,
(indices8[1] >> 2) & 0x3,
(indices8[1] >> 4) & 0x3,
(indices8[1] >> 6) & 0x3,
(indices8[2] >> 0) & 0x3,
(indices8[2] >> 2) & 0x3,
(indices8[2] >> 4) & 0x3,
(indices8[2] >> 6) & 0x3,
(indices8[3] >> 0) & 0x3,
(indices8[3] >> 2) & 0x3,
(indices8[3] >> 4) & 0x3,
(indices8[3] >> 6) & 0x3
};
const deInt32 alphaIndices[16] =
{
(deInt32)((alphaBits >> 0) & 0x7),
(deInt32)((alphaBits >> 3) & 0x7),
(deInt32)((alphaBits >> 6) & 0x7),
(deInt32)((alphaBits >> 9) & 0x7),
(deInt32)((alphaBits >> 12) & 0x7),
(deInt32)((alphaBits >> 15) & 0x7),
(deInt32)((alphaBits >> 18) & 0x7),
(deInt32)((alphaBits >> 21) & 0x7),
(deInt32)((alphaBits >> 24) & 0x7),
(deInt32)((alphaBits >> 27) & 0x7),
(deInt32)((alphaBits >> 30) & 0x7),
(deInt32)((alphaBits >> 33) & 0x7),
(deInt32)((alphaBits >> 36) & 0x7),
(deInt32)((alphaBits >> 39) & 0x7),
(deInt32)((alphaBits >> 42) & 0x7),
(deInt32)((alphaBits >> 45) & 0x7)
};
const deUint32 colors[4] =
{
color0,
color1,
interpolateColor(color1, color0),
interpolateColor(color0, color1)
};
alphas[0] = alpha0 << 24;
alphas[1] = alpha1 << 24;
if (alpha0 > alpha1)
{
for (deUint32 i = 0; i < 6; i++)
alphas[i + 2] = (((deUint32)alpha0 * (6 - i) + (deUint32)alpha1 * (1 + i)) / 7) << 24;
}
else
{
for (deUint32 i = 0; i < 4; i++)
alphas[i + 2] = (((deUint32)alpha0 * (4 - i) + (deUint32)alpha1 * (1 + i)) / 5) << 24;
alphas[6] = 0;
alphas[7] = 0xff000000;
}
for (deUint32 y = 0; y < (deUint32)BC_BLOCK_HEIGHT; y++)
{
for (deUint32 x = 0; x < (deUint32)BC_BLOCK_WIDTH; x++)
{
deUint32* const dstPixel = (deUint32*)(dstPtr + y * dstRowPitch + x * dstPixelSize);
*dstPixel = (colors[indices[y * BC_BLOCK_WIDTH + x]] & 0x00ffffff) | alphas[alphaIndices[y * BC_BLOCK_WIDTH + x]];
}
}
}
void decompressBc4 (const PixelBufferAccess& dst, const deUint8* src, bool hasSign)
{
using namespace BcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint32 dstRowPitch = dst.getRowPitch();
const deUint32 dstPixelSize = 4;
const deUint8 red0 = src[0];
const deUint8 red1 = src[1];
const deInt8 red0s = ((deInt8*)src)[0];
const deInt8 red1s = ((deInt8*)src)[1];
const deUint64 indexBits = get64BitBlockLE(src, 0) >> 16;
float reds[8];
const deInt32 indices[16] =
{
(deInt32)((indexBits >> 0) & 0x7),
(deInt32)((indexBits >> 3) & 0x7),
(deInt32)((indexBits >> 6) & 0x7),
(deInt32)((indexBits >> 9) & 0x7),
(deInt32)((indexBits >> 12) & 0x7),
(deInt32)((indexBits >> 15) & 0x7),
(deInt32)((indexBits >> 18) & 0x7),
(deInt32)((indexBits >> 21) & 0x7),
(deInt32)((indexBits >> 24) & 0x7),
(deInt32)((indexBits >> 27) & 0x7),
(deInt32)((indexBits >> 30) & 0x7),
(deInt32)((indexBits >> 33) & 0x7),
(deInt32)((indexBits >> 36) & 0x7),
(deInt32)((indexBits >> 39) & 0x7),
(deInt32)((indexBits >> 42) & 0x7),
(deInt32)((indexBits >> 45) & 0x7)
};
reds[0] = hasSign ? int8ToFloat(red0s) : uint8ToFloat(red0);
reds[1] = hasSign ? int8ToFloat(red1s) : uint8ToFloat(red1);
if (reds[0] > reds[1])
{
for (deUint32 i = 0; i < 6; i++)
reds[i + 2] = (reds[0] * (6.0f - (float)i) + reds[1] * (1.0f + (float)i)) / 7.0f;
}
else
{
for (deUint32 i = 0; i < 4; i++)
reds[i + 2] = (reds[0] * (4.0f - (float)i) + reds[1] * (1.0f + (float)i)) / 5.0f;
reds[6] = hasSign ? -1.0f : 0.0f;
reds[7] = 1.0f;
}
for (deUint32 y = 0; y < (deUint32)BC_BLOCK_HEIGHT; y++)
{
for (deUint32 x = 0; x < (deUint32)BC_BLOCK_WIDTH; x++)
{
float* const dstPixel = (float*)(dstPtr + y * dstRowPitch + x * dstPixelSize);
*dstPixel = reds[indices[y * BC_BLOCK_WIDTH + x]];
}
}
}
void decompressBc5 (const PixelBufferAccess& dst, const deUint8* src, bool hasSign)
{
using namespace BcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint32 dstRowPitch = dst.getRowPitch();
const deUint32 dstPixelSize = 8;
float rg[2][8];
deUint32 indices[2][16];
for (deUint32 c = 0; c < 2; c++)
{
const deUint32 offset = c * 8;
const deUint8 rg0 = src[offset];
const deUint8 rg1 = src[offset + 1];
const deInt8 rg0s = ((deInt8*)src)[offset];
const deInt8 rg1s = ((deInt8*)src)[offset + 1];
const deUint64 indexBits = get64BitBlockLE(src, c) >> 16;
for (deUint32 i = 0; i < 16; i++)
indices[c][i] = (indexBits >> (i * 3)) & 0x7;
rg[c][0] = hasSign ? int8ToFloat(rg0s) : uint8ToFloat(rg0);
rg[c][1] = hasSign ? int8ToFloat(rg1s) : uint8ToFloat(rg1);
if (rg[c][0] > rg[c][1])
{
for (deUint32 i = 0; i < 6; i++)
rg[c][i + 2] = (rg[c][0] * (6.0f - (float)i) + rg[c][1] * (1.0f + (float)i)) / 7.0f;
}
else
{
for (deUint32 i = 0; i < 4; i++)
rg[c][i + 2] = (rg[c][0] * (4.0f - (float)i) + rg[c][1] * (1.0f + (float)i)) / 5.0f;
rg[c][6] = hasSign ? -1.0f : 0.0f;
rg[c][7] = 1.0f;
}
}
for (deUint32 y = 0; y < (deUint32)BC_BLOCK_HEIGHT; y++)
{
for (deUint32 x = 0; x < (deUint32)BC_BLOCK_WIDTH; x++)
{
float* const dstPixel = (float*)(dstPtr + y * dstRowPitch + x * dstPixelSize);
for (deUint32 i = 0; i < 2; i++)
dstPixel[i] = rg[i][indices[i][y * BC_BLOCK_WIDTH + x]];
}
}
}
void decompressBc6H (const PixelBufferAccess& dst, const deUint8* src, bool hasSign)
{
using namespace BcDecompressInternal;
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint32 dstRowPitch = dst.getRowPitch();
const deUint32 dstPixelSize = 6;
deInt32 mode = extractModeBc6(src[0]);
IVec4 r (0);
IVec4 g (0);
IVec4 b (0);
deUint32 deltaBitsR = 0;
deUint32 deltaBitsG = 0;
deUint32 deltaBitsB = 0;
const deUint64 low = ((deUint64*)src)[0];
const deUint64 high = ((deUint64*)src)[1];
const deUint32 d = mode < 10 ? getBits128(low, high, 77, 81) : 0;
const deUint32 numRegions = mode > 9 ? 1 : 2;
const deUint32 numEndpoints = numRegions * 2;
const bool transformed = mode != 9 && mode != 10;
const deUint32 colorIndexBC = mode < 10 ? 3 : 4;
deUint64 colorIndexData = high >> (mode < 10 ? 18 : 1);
const deUint32 anchorIndex[2] = { 0, anchorIndicesSecondSubset2[d] };
switch (mode)
{
case 0:
g[2] |= getBits128(low, high, 2, 2) << 4;
b[2] |= getBits128(low, high, 3, 3) << 4;
b[3] |= getBits128(low, high, 4, 4) << 4;
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 39);
g[3] |= getBits128(low, high, 40, 40) << 4;
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 49);
b[3] |= getBits128(low, high, 50, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 59);
b[3] |= getBits128(low, high, 60, 60) << 1;
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 69);
b[3] |= getBits128(low, high, 70, 70) << 2;
r[3] |= getBits128(low, high, 71, 75);
b[3] |= getBits128(low, high, 76, 76) << 3;
deltaBitsR = deltaBitsG = deltaBitsB = 5;
break;
case 1:
g[2] |= getBits128(low, high, 2, 2) << 5;
g[3] |= getBits128(low, high, 3, 3) << 4;
g[3] |= getBits128(low, high, 4, 4) << 5;
r[0] |= getBits128(low, high, 5, 11);
b[3] |= getBits128(low, high, 12, 12);
b[3] |= getBits128(low, high, 13, 13) << 1;
b[2] |= getBits128(low, high, 14, 14) << 4;
g[0] |= getBits128(low, high, 15, 21);
b[2] |= getBits128(low, high, 22, 22) << 5;
b[3] |= getBits128(low, high, 23, 23) << 2;
g[2] |= getBits128(low, high, 24, 24) << 4;
b[0] |= getBits128(low, high, 25, 31);
b[3] |= getBits128(low, high, 32, 32) << 3;
b[3] |= getBits128(low, high, 33, 33) << 5;
b[3] |= getBits128(low, high, 34, 34) << 4;
r[1] |= getBits128(low, high, 35, 40);
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 60);
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 70);
r[3] |= getBits128(low, high, 71, 76);
deltaBitsR = deltaBitsG = deltaBitsB = 6;
break;
case 2:
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 39);
r[0] |= getBits128(low, high, 40, 40) << 10;
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 48);
g[0] |= getBits128(low, high, 49, 49) << 10;
b[3] |= getBits128(low, high, 50, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 58);
b[0] |= getBits128(low, high, 59, 59) << 10;
b[3] |= getBits128(low, high, 60, 60) << 1;
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 69);
b[3] |= getBits128(low, high, 70, 70) << 2;
r[3] |= getBits128(low, high, 71, 75);
b[3] |= getBits128(low, high, 76, 76) << 3;
deltaBitsR = 5;
deltaBitsG = deltaBitsB = 4;
break;
case 3:
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 38);
r[0] |= getBits128(low, high, 39, 39) << 10;
g[3] |= getBits128(low, high, 40, 40) << 4;
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 49);
g[0] |= getBits128(low, high, 50, 50) << 10;
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 58);
b[0] |= getBits128(low, high, 59, 59) << 10;
b[3] |= getBits128(low, high, 60, 60) << 1;
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 68);
b[3] |= getBits128(low, high, 69, 69);
b[3] |= getBits128(low, high, 70, 70) << 2;
r[3] |= getBits128(low, high, 71, 74);
g[2] |= getBits128(low, high, 75, 75) << 4;
b[3] |= getBits128(low, high, 76, 76) << 3;
deltaBitsR = deltaBitsB = 4;
deltaBitsG = 5;
break;
case 4:
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 38);
r[0] |= getBits128(low, high, 39, 39) << 10;
b[2] |= getBits128(low, high, 40, 40) << 4;
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 48);
g[0] |= getBits128(low, high, 49, 49) << 10;
b[3] |= getBits128(low, high, 50, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 59);
b[0] |= getBits128(low, high, 60, 60) << 10;
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 68);
b[3] |= getBits128(low, high, 69, 69) << 1;
b[3] |= getBits128(low, high, 70, 70) << 2;
r[3] |= getBits128(low, high, 71, 74);
b[3] |= getBits128(low, high, 75, 75) << 4;
b[3] |= getBits128(low, high, 76, 76) << 3;
deltaBitsR = deltaBitsG = 4;
deltaBitsB = 5;
break;
case 5:
r[0] |= getBits128(low, high, 5, 13);
b[2] |= getBits128(low, high, 14, 14) << 4;
g[0] |= getBits128(low, high, 15, 23);
g[2] |= getBits128(low, high, 24, 24) << 4;
b[0] |= getBits128(low, high, 25, 33);
b[3] |= getBits128(low, high, 34, 34) << 4;
r[1] |= getBits128(low, high, 35, 39);
g[3] |= getBits128(low, high, 40, 40) << 4;
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 49);
b[3] |= getBits128(low, high, 50, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 59);
b[3] |= getBits128(low, high, 60, 60) << 1;
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 69);
b[3] |= getBits128(low, high, 70, 70) << 2;
r[3] |= getBits128(low, high, 71, 75);
b[3] |= getBits128(low, high, 76, 76) << 3;
deltaBitsR = deltaBitsG = deltaBitsB = 5;
break;
case 6:
r[0] |= getBits128(low, high, 5, 12);
g[3] |= getBits128(low, high, 13, 13) << 4;
b[2] |= getBits128(low, high, 14, 14) << 4;
g[0] |= getBits128(low, high, 15, 22);
b[3] |= getBits128(low, high, 23, 23) << 2;
g[2] |= getBits128(low, high, 24, 24) << 4;
b[0] |= getBits128(low, high, 25, 32);
b[3] |= getBits128(low, high, 33, 33) << 3;
b[3] |= getBits128(low, high, 34, 34) << 4;
r[1] |= getBits128(low, high, 35, 40);
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 49);
b[3] |= getBits128(low, high, 50, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 59);
b[3] |= getBits128(low, high, 60, 60) << 1;
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 70);
r[3] |= getBits128(low, high, 71, 76);
deltaBitsR = 6;
deltaBitsG = deltaBitsB = 5;
break;
case 7:
r[0] |= getBits128(low, high, 5, 12);
b[3] |= getBits128(low, high, 13, 13);
b[2] |= getBits128(low, high, 14, 14) << 4;
g[0] |= getBits128(low, high, 15, 22);
g[2] |= getBits128(low, high, 23, 23) << 5;
g[2] |= getBits128(low, high, 24, 24) << 4;
b[0] |= getBits128(low, high, 25, 32);
g[3] |= getBits128(low, high, 33, 33) << 5;
b[3] |= getBits128(low, high, 34, 34) << 4;
r[1] |= getBits128(low, high, 35, 39);
g[3] |= getBits128(low, high, 40, 40) << 4;
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 59);
b[3] |= getBits128(low, high, 60, 60) << 1;
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 69);
b[3] |= getBits128(low, high, 70, 70) << 2;
r[3] |= getBits128(low, high, 71, 75);
b[3] |= getBits128(low, high, 76, 76) << 3;
deltaBitsR = deltaBitsB = 5;
deltaBitsG = 6;
break;
case 8:
r[0] |= getBits128(low, high, 5, 12);
b[3] |= getBits128(low, high, 13, 13) << 1;
b[2] |= getBits128(low, high, 14, 14) << 4;
g[0] |= getBits128(low, high, 15, 22);
b[2] |= getBits128(low, high, 23, 23) << 5;
g[2] |= getBits128(low, high, 24, 24) << 4;
b[0] |= getBits128(low, high, 25, 32);
b[3] |= getBits128(low, high, 33, 33) << 5;
b[3] |= getBits128(low, high, 34, 34) << 4;
r[1] |= getBits128(low, high, 35, 39);
g[3] |= getBits128(low, high, 40, 40) << 4;
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 49);
b[3] |= getBits128(low, high, 50, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 60);
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 69);
b[3] |= getBits128(low, high, 70, 70) << 2;
r[3] |= getBits128(low, high, 71, 75);
b[3] |= getBits128(low, high, 76, 76) << 3;
deltaBitsR = deltaBitsG = 5;
deltaBitsB = 6;
break;
case 9:
r[0] |= getBits128(low, high, 5, 10);
g[3] |= getBits128(low, high, 11, 11) << 4;
b[3] |= getBits128(low, high, 12, 13);
b[2] |= getBits128(low, high, 14, 14) << 4;
g[0] |= getBits128(low, high, 15, 20);
g[2] |= getBits128(low, high, 21, 21) << 5;
b[2] |= getBits128(low, high, 22, 22) << 5;
b[3] |= getBits128(low, high, 23, 23) << 2;
g[2] |= getBits128(low, high, 24, 24) << 4;
b[0] |= getBits128(low, high, 25, 30);
g[3] |= getBits128(low, high, 31, 31) << 5;
b[3] |= getBits128(low, high, 32, 32) << 3;
b[3] |= getBits128(low, high, 33, 33) << 5;
b[3] |= getBits128(low, high, 34, 34) << 4;
r[1] |= getBits128(low, high, 35, 40);
g[2] |= getBits128(low, high, 41, 44);
g[1] |= getBits128(low, high, 45, 50);
g[3] |= getBits128(low, high, 51, 54);
b[1] |= getBits128(low, high, 55, 60);
b[2] |= getBits128(low, high, 61, 64);
r[2] |= getBits128(low, high, 65, 70);
r[3] |= getBits128(low, high, 71, 76);
deltaBitsR = deltaBitsG = deltaBitsB = 6;
break;
case 10:
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 44);
g[1] |= getBits128(low, high, 45, 54);
b[1] |= getBits128(low, high, 55, 64);
deltaBitsR = deltaBitsG = deltaBitsB = 10;
break;
case 11:
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 43);
r[0] |= getBits128(low, high, 44, 44) << 10;
g[1] |= getBits128(low, high, 45, 53);
g[0] |= getBits128(low, high, 54, 54) << 10;
b[1] |= getBits128(low, high, 55, 63);
b[0] |= getBits128(low, high, 64, 64) << 10;
deltaBitsR = deltaBitsG = deltaBitsB = 9;
break;
case 12:
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 42);
r[0] |= getBits128(low, high, 44, 43) << 10;
g[1] |= getBits128(low, high, 45, 52);
g[0] |= getBits128(low, high, 54, 53) << 10;
b[1] |= getBits128(low, high, 55, 62);
b[0] |= getBits128(low, high, 64, 63) << 10;
deltaBitsR = deltaBitsG = deltaBitsB = 8;
break;
case 13:
r[0] |= getBits128(low, high, 5, 14);
g[0] |= getBits128(low, high, 15, 24);
b[0] |= getBits128(low, high, 25, 34);
r[1] |= getBits128(low, high, 35, 38);
r[0] |= getBits128(low, high, 44, 39) << 10;
g[1] |= getBits128(low, high, 45, 48);
g[0] |= getBits128(low, high, 54, 49) << 10;
b[1] |= getBits128(low, high, 55, 58);
b[0] |= getBits128(low, high, 64, 59) << 10;
deltaBitsR = deltaBitsG = deltaBitsB = 4;
break;
};
if (hasSign)
{
r[0] = signExtend(r[0], epBits[mode], 32);
g[0] = signExtend(g[0], epBits[mode], 32);
b[0] = signExtend(b[0], epBits[mode], 32);
}
if (transformed)
{
for (deUint32 i = 1; i < numEndpoints; i++)
{
r[i] = signExtend(r[i], deltaBitsR, 32);
r[i] = (r[0] + r[i]) & (((deUint32)1 << epBits[mode]) - 1);
g[i] = signExtend(g[i], deltaBitsG, 32);
g[i] = (g[0] + g[i]) & (((deUint32)1 << epBits[mode]) - 1);
b[i] = signExtend(b[i], deltaBitsB, 32);
b[i] = (b[0] + b[i]) & (((deUint32)1 << epBits[mode]) - 1);
}
}
if (hasSign)
{
for (deUint32 i = 1; i < 4; i++)
{
r[i] = signExtend(r[i], epBits[mode], 32);
g[i] = signExtend(g[i], epBits[mode], 32);
b[i] = signExtend(b[i], epBits[mode], 32);
}
}
for (deUint32 i = 0; i < numEndpoints; i++)
{
r[i] = unquantize(r[i], mode, hasSign);
g[i] = unquantize(g[i], mode, hasSign);
b[i] = unquantize(b[i], mode, hasSign);
}
for (deUint32 i = 0; i < 16; i++)
{
const deUint32 subsetIndex = (numRegions == 1 ? 0 : partitions2[d][i]);
const deUint32 bits = (i == anchorIndex[subsetIndex]) ? (colorIndexBC - 1) : colorIndexBC;
const deUint32 colorIndex = (deUint32)(colorIndexData & ((1 << bits) - 1));
const deInt32 endpointStartR = r[2 * subsetIndex];
const deInt32 endpointEndR = r[2 * subsetIndex + 1];
const deInt32 endpointStartG = g[2 * subsetIndex];
const deInt32 endpointEndG = g[2 * subsetIndex + 1];
const deInt32 endpointStartB = b[2 * subsetIndex];
const deInt32 endpointEndB = b[2 * subsetIndex + 1];
const deInt16 r16 = finishUnquantize(interpolate(endpointStartR, endpointEndR, colorIndex, colorIndexBC), hasSign);
const deInt16 g16 = finishUnquantize(interpolate(endpointStartG, endpointEndG, colorIndex, colorIndexBC), hasSign);
const deInt16 b16 = finishUnquantize(interpolate(endpointStartB, endpointEndB, colorIndex, colorIndexBC), hasSign);
const deInt32 y = i / 4;
const deInt32 x = i % 4;
deInt16* const dstPixel = (deInt16*)(dstPtr + y * dstRowPitch + x * dstPixelSize);
if (mode == -1)
{
dstPixel[0] = 0;
dstPixel[1] = 0;
dstPixel[2] = 0;
}
else
{
dstPixel[0] = r16;
dstPixel[1] = g16;
dstPixel[2] = b16;
}
colorIndexData >>= bits;
}
}
void decompressBc7 (const PixelBufferAccess& dst, const deUint8* src)
{
using namespace BcDecompressInternal;
static const deUint8 subsets[] = { 3, 2, 3, 2, 1, 1, 1, 2 };
static const deUint8 partitionBits[] = { 4, 6, 6, 6, 0, 0, 0, 6 };
static const deUint8 endpointBits[8][5] =
{
//r, g, b, a, p
{ 4, 4, 4, 0, 1 },
{ 6, 6, 6, 0, 1 },
{ 5, 5, 5, 0, 0 },
{ 7, 7, 7, 0, 1 },
{ 5, 5, 5, 6, 0 },
{ 7, 7, 7, 8, 0 },
{ 7, 7, 7, 7, 1 },
{ 5, 5, 5, 5, 1 }
};
static const deUint8 indexBits[] = { 3, 3, 2, 2, 2, 2, 4, 2 };
deUint8* const dstPtr = (deUint8*)dst.getDataPtr();
const deUint32 dstRowPitch = dst.getRowPitch();
const deUint32 dstPixelSize = 4;
const deUint64 low = ((deUint64*)src)[0];
const deUint64 high = ((deUint64*)src)[1];
const deInt32 mode = extractModeBc7(src[0]);
deUint32 numSubsets = 1;
deUint32 offset = mode + 1;
deUint32 rotation = 0;
deUint32 idxMode = 0;
deUint32 endpoints[6][5];
deUint32 partitionSetId = 0;
// Decode partition data from explicit partition bits
if (mode == 0 || mode == 1 || mode == 2 || mode == 3 || mode == 7)
{
numSubsets = subsets[mode];
partitionSetId = getBits128(low, high, offset, offset + partitionBits[mode] - 1);
offset += partitionBits[mode];
}
// Extract rotation bits
if (mode == 4 || mode == 5)
{
rotation = getBits128(low, high, offset, offset + 1);
offset += 2;
if (mode == 4)
{
idxMode = getBits128(low, high, offset, offset);
offset++;
}
}
{
const deUint32 numEndpoints = numSubsets * 2;
// Extract raw, compressed endpoint bits
for (deUint32 cpnt = 0; cpnt < 5; cpnt++)
{
for (deUint32 ep = 0; ep < numEndpoints; ep++)
{
if (mode == 1 && cpnt == 4 && ep > 1)
continue; // Mode 1 has shared P bits
int n = mode == -1 ? 0 : endpointBits[mode][cpnt];
if (n > 0)
endpoints[ep][cpnt] = getBits128(low, high, offset, offset + n - 1);
offset += n;
}
}
// Decode endpoints
if (mode == 0 || mode == 1 || mode == 3 || mode == 6 || mode == 7)
{
// First handle modes that have P-bits
for (deUint32 ep = 0; ep < numEndpoints; ep++)
{
for (deUint32 cpnt = 0; cpnt < 4; cpnt++)
{
endpoints[ep][cpnt] <<= 1;
}
}
if (mode == 1)
{
// P-bit is shared
const deUint32 pbitZero = endpoints[0][4];
const deUint32 pbitOne = endpoints[1][4];
for (deUint32 cpnt = 0; cpnt < 3; cpnt++)
{
endpoints[0][cpnt] |= pbitZero;
endpoints[1][cpnt] |= pbitZero;
endpoints[2][cpnt] |= pbitOne;
endpoints[3][cpnt] |= pbitOne;
}
}
else
{
// Unique p-bit per endpoint
for (deUint32 ep = 0; ep < numEndpoints; ep++)
{
for (deUint32 cpnt = 0; cpnt < 4; cpnt++)
{
endpoints[ep][cpnt] |= endpoints[ep][4];
}
}
}
}
for (deUint32 ep = 0; ep < numEndpoints; ep++)
{
// Left shift endpoint components so that their MSB lies in bit 7
for (deUint32 cpnt = 0; cpnt < 4; cpnt++)
endpoints[ep][cpnt] <<= 8 - (endpointBits[mode][cpnt] + endpointBits[mode][4]);
// Replicate each component's MSB into the LSBs revealed by the left-shift operation above
for (deUint32 cpnt = 0; cpnt < 4; cpnt++)
endpoints[ep][cpnt] |= endpoints[ep][cpnt] >> (endpointBits[mode][cpnt] + endpointBits[mode][4]);
}
// If this mode does not explicitly define the alpha component set alpha equal to 1.0
if (mode < 4)
{
for (deUint32 ep = 0; ep < numEndpoints; ep++)
endpoints[ep][3] = 255;
}
}
{
deUint32 colorIdxOffset = offset + ((mode == 4 && idxMode) ? 31 : 0);
deUint32 alphaIdxOffset = offset + ((mode == 5 || (mode == 4 && !idxMode)) ? 31 : 0);
for (deUint32 pixel = 0; pixel < 16; pixel++)
{
const deUint32 y = pixel / 4;
const deUint32 x = pixel % 4;
deUint32* const dstPixel = (deUint32*)(dstPtr + y * dstRowPitch + x * dstPixelSize);
deUint32 subsetIndex = 0;
deUint32 anchorIndex = 0;
deUint32 endpointStart[4];
deUint32 endpointEnd[4];
if (mode == -1)
{
*dstPixel = 0;
continue;
}
if (numSubsets == 2)
subsetIndex = partitions2[partitionSetId][pixel];
else if (numSubsets == 3)
subsetIndex = partitions3[partitionSetId][pixel];
if (numSubsets == 2 && subsetIndex == 1)
{
anchorIndex = anchorIndicesSecondSubset2[partitionSetId];
}
else if (numSubsets == 3)
{
if (subsetIndex == 1)
anchorIndex = anchorIndicesSecondSubset3[partitionSetId];
else if (subsetIndex == 2)
anchorIndex = anchorIndicesThirdSubset[partitionSetId];
}
for (deUint32 cpnt = 0; cpnt < 4; cpnt++)
{
endpointStart[cpnt] = endpoints[2 * subsetIndex][cpnt];
endpointEnd[cpnt] = endpoints[2 * subsetIndex + 1][cpnt];
}
{
const deUint32 colorInterpolationBits = indexBits[mode] + idxMode;
const deUint32 colorIndexBits = colorInterpolationBits - ((anchorIndex == pixel) ? 1 : 0);
const deUint32 alphaInterpolationBits = mode == 4 ? 3 - idxMode : (mode == 5 ? 2 : colorInterpolationBits);
const deUint32 alphaIndexBits = alphaInterpolationBits - ((anchorIndex == pixel) ? 1 : 0);
const deUint32 colorIdx = getBits128(low, high, colorIdxOffset, colorIdxOffset + colorIndexBits - 1);
const deUint32 alphaIdx = (mode == 4 || mode == 5) ? getBits128(low, high, alphaIdxOffset, alphaIdxOffset + alphaIndexBits - 1) : colorIdx;
const deUint32 r = interpolate(endpointStart[0], endpointEnd[0], colorIdx, colorInterpolationBits);
const deUint32 g = interpolate(endpointStart[1], endpointEnd[1], colorIdx, colorInterpolationBits);
const deUint32 b = interpolate(endpointStart[2], endpointEnd[2], colorIdx, colorInterpolationBits);
const deUint32 a = interpolate(endpointStart[3], endpointEnd[3], alphaIdx, alphaInterpolationBits);
colorIdxOffset += colorIndexBits;
alphaIdxOffset += alphaIndexBits;
if ((mode == 4 || mode == 5) && rotation != 0)
{
if (rotation == 1)
*dstPixel = a | (g << 8) | (b << 16) | (r << 24);
else if (rotation == 2)
*dstPixel = r | (a << 8) | (b << 16) | (g << 24);
else
*dstPixel = r | (g << 8) | (a << 16) | (b << 24);
}
else
{
*dstPixel = r | (g << 8) | (b << 16) | (a << 24);
}
}
}
}
}
void decompressBlock (CompressedTexFormat format, const PixelBufferAccess& dst, const deUint8* src, const TexDecompressionParams& params)
{
// No 3D blocks supported right now
DE_ASSERT(dst.getDepth() == 1);
switch (format)
{
case COMPRESSEDTEXFORMAT_ETC1_RGB8: decompressETC1 (dst, src); break;
case COMPRESSEDTEXFORMAT_EAC_R11: decompressEAC_R11 (dst, src, false); break;
case COMPRESSEDTEXFORMAT_EAC_SIGNED_R11: decompressEAC_R11 (dst, src, true); break;
case COMPRESSEDTEXFORMAT_EAC_RG11: decompressEAC_RG11 (dst, src, false); break;
case COMPRESSEDTEXFORMAT_EAC_SIGNED_RG11: decompressEAC_RG11 (dst, src, true); break;
case COMPRESSEDTEXFORMAT_ETC2_RGB8: decompressETC2 (dst, src); break;
case COMPRESSEDTEXFORMAT_ETC2_SRGB8: decompressETC2 (dst, src); break;
case COMPRESSEDTEXFORMAT_ETC2_RGB8_PUNCHTHROUGH_ALPHA1: decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1 (dst, src); break;
case COMPRESSEDTEXFORMAT_ETC2_SRGB8_PUNCHTHROUGH_ALPHA1: decompressETC2_RGB8_PUNCHTHROUGH_ALPHA1 (dst, src); break;
case COMPRESSEDTEXFORMAT_ETC2_EAC_RGBA8: decompressETC2_EAC_RGBA8 (dst, src); break;
case COMPRESSEDTEXFORMAT_ETC2_EAC_SRGB8_ALPHA8: decompressETC2_EAC_RGBA8 (dst, src); break;
case COMPRESSEDTEXFORMAT_ASTC_4x4_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_5x4_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_5x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_6x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_6x6_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_8x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_8x6_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_8x8_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x5_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x6_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x8_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_10x10_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_12x10_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_12x12_RGBA:
case COMPRESSEDTEXFORMAT_ASTC_4x4_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_5x4_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_5x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_6x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_6x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_8x8_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x5_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x6_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x8_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_10x10_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_12x10_SRGB8_ALPHA8:
case COMPRESSEDTEXFORMAT_ASTC_12x12_SRGB8_ALPHA8:
astc::decompress(dst, src, format, params.astcMode);
break;
case COMPRESSEDTEXFORMAT_BC1_RGB_UNORM_BLOCK: decompressBc1 (dst, src, false); break;
case COMPRESSEDTEXFORMAT_BC1_RGB_SRGB_BLOCK: decompressBc1 (dst, src, false); break;
case COMPRESSEDTEXFORMAT_BC1_RGBA_UNORM_BLOCK: decompressBc1 (dst, src, true); break;
case COMPRESSEDTEXFORMAT_BC1_RGBA_SRGB_BLOCK: decompressBc1 (dst, src, true); break;
case COMPRESSEDTEXFORMAT_BC2_UNORM_BLOCK: decompressBc2 (dst, src); break;
case COMPRESSEDTEXFORMAT_BC2_SRGB_BLOCK: decompressBc2 (dst, src); break;
case COMPRESSEDTEXFORMAT_BC3_UNORM_BLOCK: decompressBc3 (dst, src); break;
case COMPRESSEDTEXFORMAT_BC3_SRGB_BLOCK: decompressBc3 (dst, src); break;
case COMPRESSEDTEXFORMAT_BC4_UNORM_BLOCK: decompressBc4 (dst, src, false); break;
case COMPRESSEDTEXFORMAT_BC4_SNORM_BLOCK: decompressBc4 (dst, src, true); break;
case COMPRESSEDTEXFORMAT_BC5_UNORM_BLOCK: decompressBc5 (dst, src, false); break;
case COMPRESSEDTEXFORMAT_BC5_SNORM_BLOCK: decompressBc5 (dst, src, true); break;
case COMPRESSEDTEXFORMAT_BC6H_UFLOAT_BLOCK: decompressBc6H (dst, src, false); break;
case COMPRESSEDTEXFORMAT_BC6H_SFLOAT_BLOCK: decompressBc6H (dst, src, true); break;
case COMPRESSEDTEXFORMAT_BC7_UNORM_BLOCK: decompressBc7 (dst, src); break;
case COMPRESSEDTEXFORMAT_BC7_SRGB_BLOCK: decompressBc7 (dst, src); break;
default:
DE_FATAL("Unexpected format");
break;
}
}
int componentSum (const IVec3& vec)
{
return vec.x() + vec.y() + vec.z();
}
} // anonymous
void decompress (const PixelBufferAccess& dst, CompressedTexFormat fmt, const deUint8* src, const TexDecompressionParams& params)
{
const int blockSize = getBlockSize(fmt);
const IVec3 blockPixelSize (getBlockPixelSize(fmt));
const IVec3 blockCount (deDivRoundUp32(dst.getWidth(), blockPixelSize.x()),
deDivRoundUp32(dst.getHeight(), blockPixelSize.y()),
deDivRoundUp32(dst.getDepth(), blockPixelSize.z()));
const IVec3 blockPitches (blockSize, blockSize * blockCount.x(), blockSize * blockCount.x() * blockCount.y());
std::vector<deUint8> uncompressedBlock (dst.getFormat().getPixelSize() * blockPixelSize.x() * blockPixelSize.y() * blockPixelSize.z());
const PixelBufferAccess blockAccess (getUncompressedFormat(fmt), blockPixelSize.x(), blockPixelSize.y(), blockPixelSize.z(), &uncompressedBlock[0]);
DE_ASSERT(dst.getFormat() == getUncompressedFormat(fmt));
for (int blockZ = 0; blockZ < blockCount.z(); blockZ++)
for (int blockY = 0; blockY < blockCount.y(); blockY++)
for (int blockX = 0; blockX < blockCount.x(); blockX++)
{
const IVec3 blockPos (blockX, blockY, blockZ);
const deUint8* const blockPtr = src + componentSum(blockPos * blockPitches);
const IVec3 copySize (de::min(blockPixelSize.x(), dst.getWidth() - blockPos.x() * blockPixelSize.x()),
de::min(blockPixelSize.y(), dst.getHeight() - blockPos.y() * blockPixelSize.y()),
de::min(blockPixelSize.z(), dst.getDepth() - blockPos.z() * blockPixelSize.z()));
const IVec3 dstPixelPos = blockPos * blockPixelSize;
decompressBlock(fmt, blockAccess, blockPtr, params);
copy(getSubregion(dst, dstPixelPos.x(), dstPixelPos.y(), dstPixelPos.z(), copySize.x(), copySize.y(), copySize.z()), getSubregion(blockAccess, 0, 0, 0, copySize.x(), copySize.y(), copySize.z()));
}
}
CompressedTexture::CompressedTexture (void)
: m_format (COMPRESSEDTEXFORMAT_LAST)
, m_width (0)
, m_height (0)
, m_depth (0)
{
}
CompressedTexture::CompressedTexture (CompressedTexFormat format, int width, int height, int depth)
: m_format (COMPRESSEDTEXFORMAT_LAST)
, m_width (0)
, m_height (0)
, m_depth (0)
{
setStorage(format, width, height, depth);
}
CompressedTexture::~CompressedTexture (void)
{
}
void CompressedTexture::setStorage (CompressedTexFormat format, int width, int height, int depth)
{
m_format = format;
m_width = width;
m_height = height;
m_depth = depth;
if (m_format != COMPRESSEDTEXFORMAT_LAST)
{
const IVec3 blockPixelSize = getBlockPixelSize(m_format);
const int blockSize = getBlockSize(m_format);
m_data.resize(deDivRoundUp32(m_width, blockPixelSize.x()) * deDivRoundUp32(m_height, blockPixelSize.y()) * deDivRoundUp32(m_depth, blockPixelSize.z()) * blockSize);
}
else
{
DE_ASSERT(m_format == COMPRESSEDTEXFORMAT_LAST);
DE_ASSERT(m_width == 0 && m_height == 0 && m_depth == 0);
m_data.resize(0);
}
}
/*--------------------------------------------------------------------*//*!
* \brief Decode to uncompressed pixel data
* \param dst Destination buffer
*//*--------------------------------------------------------------------*/
void CompressedTexture::decompress (const PixelBufferAccess& dst, const TexDecompressionParams& params) const
{
DE_ASSERT(dst.getWidth() == m_width && dst.getHeight() == m_height && dst.getDepth() == m_depth);
DE_ASSERT(dst.getFormat() == getUncompressedFormat(m_format));
tcu::decompress(dst, m_format, &m_data[0], params);
}
} // tcu