| /*------------------------------------------------------------------------- |
| * 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 if (isAhbRawFormat(format)) |
| { |
| switch (format) |
| { |
| case COMPRESSEDTEXFORMAT_AHB_RAW10: |
| return 5; |
| case COMPRESSEDTEXFORMAT_AHB_RAW12: |
| return 3; |
| |
| 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 if (isAhbRawFormat(format)) |
| { |
| switch (format) |
| { |
| case COMPRESSEDTEXFORMAT_AHB_RAW10: |
| return IVec3(4, 1, 1); |
| case COMPRESSEDTEXFORMAT_AHB_RAW12: |
| return IVec3(2, 1, 1); |
| |
| default: |
| DE_ASSERT(false); |
| return IVec3(); |
| } |
| } |
| 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; |
| } |
| } |
| |
| bool isAhbRawFormat(CompressedTexFormat format) |
| { |
| switch (format) |
| { |
| case COMPRESSEDTEXFORMAT_AHB_RAW10: |
| case COMPRESSEDTEXFORMAT_AHB_RAW12: |
| 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 if (isAhbRawFormat(format)) |
| { |
| if (format == COMPRESSEDTEXFORMAT_AHB_RAW10) |
| return TextureFormat(TextureFormat::R, |
| TextureFormat::UNORM_SHORT_10); // Can be changed to a more fitting value if needed |
| else // COMPRESSEDTEXFORMAT_AHB_RAW12 |
| return TextureFormat(TextureFormat::R, |
| TextureFormat::UNORM_SHORT_12); // Can be changed to a more fitting value if needed |
| } |
| 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 uint8_t extend4To8(uint8_t src) |
| { |
| DE_ASSERT((src & ~((1 << 4) - 1)) == 0); |
| return (uint8_t)((src << 4) | src); |
| } |
| |
| inline uint8_t extend5To8(uint8_t src) |
| { |
| DE_ASSERT((src & ~((1 << 5) - 1)) == 0); |
| return (uint8_t)((src << 3) | (src >> 2)); |
| } |
| |
| inline uint8_t extend6To8(uint8_t src) |
| { |
| DE_ASSERT((src & ~((1 << 6) - 1)) == 0); |
| return (uint8_t)((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 uint64_t get64BitBlock(const uint8_t *src, int blockNdx) |
| { |
| // Stored in big-endian form. |
| uint64_t block = 0; |
| |
| for (int i = 0; i < 8; i++) |
| block = (block << 8ull) | (uint64_t)(src[blockNdx * 8 + i]); |
| |
| return block; |
| } |
| |
| // Return the first 64 bits of a 128 bit block. |
| inline uint64_t get128BitBlockStart(const uint8_t *src, int blockNdx) |
| { |
| return get64BitBlock(src, 2 * blockNdx); |
| } |
| |
| // Return the last 64 bits of a 128 bit block. |
| inline uint64_t get128BitBlockEnd(const uint8_t *src, int blockNdx) |
| { |
| return get64BitBlock(src, 2 * blockNdx + 1); |
| } |
| |
| inline uint32_t getBit(uint64_t src, int bit) |
| { |
| return (src >> bit) & 1; |
| } |
| |
| inline uint32_t getBits(uint64_t src, int low, int high) |
| { |
| const int numBits = (high - low) + 1; |
| DE_ASSERT(de::inRange(numBits, 1, 32)); |
| if (numBits < 32) |
| return (uint32_t)((src >> low) & ((1u << numBits) - 1)); |
| else |
| return (uint32_t)((src >> low) & 0xFFFFFFFFu); |
| } |
| |
| inline uint8_t extend7To8(uint8_t src) |
| { |
| DE_ASSERT((src & ~((1 << 7) - 1)) == 0); |
| return (uint8_t)((src << 1) | (src >> 6)); |
| } |
| |
| inline int8_t extendSigned3To8(uint8_t src) |
| { |
| const bool isNeg = (src & (1 << 2)) != 0; |
| return (int8_t)((isNeg ? ~((1 << 3) - 1) : 0) | src); |
| } |
| |
| inline uint8_t extend5Delta3To8(uint8_t base5, uint8_t delta3) |
| { |
| const uint8_t t = (uint8_t)((int8_t)base5 + extendSigned3To8(delta3)); |
| return extend5To8(t); |
| } |
| |
| inline uint16_t extend11To16(uint16_t src) |
| { |
| DE_ASSERT((src & ~((1 << 11) - 1)) == 0); |
| return (uint16_t)((src << 5) | (src >> 6)); |
| } |
| |
| inline int16_t extend11To16WithSign(int16_t src) |
| { |
| if (src < 0) |
| return (int16_t)(-(int16_t)extend11To16((uint16_t)(-src))); |
| else |
| return (int16_t)extend11To16(src); |
| } |
| |
| void decompressETC1Block(uint8_t dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8], uint64_t src) |
| { |
| const int diffBit = (int)getBit(src, 33); |
| const int flipBit = (int)getBit(src, 32); |
| const uint32_t table[2] = {getBits(src, 37, 39), getBits(src, 34, 36)}; |
| uint8_t baseR[2]; |
| uint8_t baseG[2]; |
| uint8_t baseB[2]; |
| |
| if (diffBit == 0) |
| { |
| // Individual mode. |
| baseR[0] = extend4To8((uint8_t)getBits(src, 60, 63)); |
| baseR[1] = extend4To8((uint8_t)getBits(src, 56, 59)); |
| baseG[0] = extend4To8((uint8_t)getBits(src, 52, 55)); |
| baseG[1] = extend4To8((uint8_t)getBits(src, 48, 51)); |
| baseB[0] = extend4To8((uint8_t)getBits(src, 44, 47)); |
| baseB[1] = extend4To8((uint8_t)getBits(src, 40, 43)); |
| } |
| else |
| { |
| // Differential mode (diffBit == 1). |
| uint8_t bR = (uint8_t)getBits(src, 59, 63); // 5b |
| uint8_t dR = (uint8_t)getBits(src, 56, 58); // 3b |
| uint8_t bG = (uint8_t)getBits(src, 51, 55); |
| uint8_t dG = (uint8_t)getBits(src, 48, 50); |
| uint8_t bB = (uint8_t)getBits(src, 43, 47); |
| uint8_t dB = (uint8_t)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 uint32_t tableNdx = table[subBlock]; |
| const uint32_t modifierNdx = (getBit(src, 16 + pixelNdx) << 1) | getBit(src, pixelNdx); |
| const int modifier = modifierTable[tableNdx][modifierNdx]; |
| |
| dst[dstOffset + 0] = (uint8_t)deClamp32((int)baseR[subBlock] + modifier, 0, 255); |
| dst[dstOffset + 1] = (uint8_t)deClamp32((int)baseG[subBlock] + modifier, 0, 255); |
| dst[dstOffset + 2] = (uint8_t)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(uint8_t dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8], uint64_t src, |
| uint8_t 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 int8_t selBR = (int8_t)getBits(src, 59, 63); // 5 bits. |
| const int8_t selBG = (int8_t)getBits(src, 51, 55); |
| const int8_t selBB = (int8_t)getBits(src, 43, 47); |
| const int8_t selDR = extendSigned3To8((uint8_t)getBits(src, 56, 58)); // 3 bits. |
| const int8_t selDG = extendSigned3To8((uint8_t)getBits(src, 48, 50)); |
| const int8_t selDB = extendSigned3To8((uint8_t)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 uint32_t table[2] = {getBits(src, 37, 39), getBits(src, 34, 36)}; |
| uint8_t baseR[2]; |
| uint8_t baseG[2]; |
| uint8_t baseB[2]; |
| |
| if (mode == MODE_INDIVIDUAL) |
| { |
| // Individual mode, initial values. |
| baseR[0] = extend4To8((uint8_t)getBits(src, 60, 63)); |
| baseR[1] = extend4To8((uint8_t)getBits(src, 56, 59)); |
| baseG[0] = extend4To8((uint8_t)getBits(src, 52, 55)); |
| baseG[1] = extend4To8((uint8_t)getBits(src, 48, 51)); |
| baseB[0] = extend4To8((uint8_t)getBits(src, 44, 47)); |
| baseB[1] = extend4To8((uint8_t)getBits(src, 40, 43)); |
| } |
| else |
| { |
| // Differential mode, initial values. |
| baseR[0] = extend5To8(selBR); |
| baseG[0] = extend5To8(selBG); |
| baseB[0] = extend5To8(selBB); |
| |
| baseR[1] = extend5To8((uint8_t)(selBR + selDR)); |
| baseG[1] = extend5To8((uint8_t)(selBG + selDG)); |
| baseB[1] = extend5To8((uint8_t)(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 uint32_t tableNdx = table[subBlock]; |
| const uint32_t 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] = (uint8_t)deClamp32((int)baseR[subBlock] + modifier, 0, 255); |
| dst[dstOffset + 1] = (uint8_t)deClamp32((int)baseG[subBlock] + modifier, 0, 255); |
| dst[dstOffset + 2] = (uint8_t)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}; |
| |
| uint8_t paintR[4]; |
| uint8_t paintG[4]; |
| uint8_t paintB[4]; |
| |
| if (mode == MODE_T) |
| { |
| // T mode, calculate paint values. |
| const uint8_t R1a = (uint8_t)getBits(src, 59, 60); |
| const uint8_t R1b = (uint8_t)getBits(src, 56, 57); |
| const uint8_t G1 = (uint8_t)getBits(src, 52, 55); |
| const uint8_t B1 = (uint8_t)getBits(src, 48, 51); |
| const uint8_t R2 = (uint8_t)getBits(src, 44, 47); |
| const uint8_t G2 = (uint8_t)getBits(src, 40, 43); |
| const uint8_t B2 = (uint8_t)getBits(src, 36, 39); |
| const uint32_t distNdx = (getBits(src, 34, 35) << 1) | getBit(src, 32); |
| const int dist = distTable[distNdx]; |
| |
| paintR[0] = extend4To8((uint8_t)((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] = (uint8_t)deClamp32((int)paintR[2] + dist, 0, 255); |
| paintG[1] = (uint8_t)deClamp32((int)paintG[2] + dist, 0, 255); |
| paintB[1] = (uint8_t)deClamp32((int)paintB[2] + dist, 0, 255); |
| paintR[3] = (uint8_t)deClamp32((int)paintR[2] - dist, 0, 255); |
| paintG[3] = (uint8_t)deClamp32((int)paintG[2] - dist, 0, 255); |
| paintB[3] = (uint8_t)deClamp32((int)paintB[2] - dist, 0, 255); |
| } |
| else |
| { |
| // H mode, calculate paint values. |
| const uint8_t R1 = (uint8_t)getBits(src, 59, 62); |
| const uint8_t G1a = (uint8_t)getBits(src, 56, 58); |
| const uint8_t G1b = (uint8_t)getBit(src, 52); |
| const uint8_t B1a = (uint8_t)getBit(src, 51); |
| const uint8_t B1b = (uint8_t)getBits(src, 47, 49); |
| const uint8_t R2 = (uint8_t)getBits(src, 43, 46); |
| const uint8_t G2 = (uint8_t)getBits(src, 39, 42); |
| const uint8_t B2 = (uint8_t)getBits(src, 35, 38); |
| uint8_t baseR[2]; |
| uint8_t baseG[2]; |
| uint8_t baseB[2]; |
| uint32_t baseValue[2]; |
| uint32_t distNdx; |
| int dist; |
| |
| baseR[0] = extend4To8(R1); |
| baseG[0] = extend4To8((uint8_t)((G1a << 1) | G1b)); |
| baseB[0] = extend4To8((uint8_t)((B1a << 3) | B1b)); |
| baseR[1] = extend4To8(R2); |
| baseG[1] = extend4To8(G2); |
| baseB[1] = extend4To8(B2); |
| baseValue[0] = (((uint32_t)baseR[0]) << 16) | (((uint32_t)baseG[0]) << 8) | baseB[0]; |
| baseValue[1] = (((uint32_t)baseR[1]) << 16) | (((uint32_t)baseG[1]) << 8) | baseB[1]; |
| distNdx = (getBit(src, 34) << 2) | (getBit(src, 32) << 1) | (uint32_t)(baseValue[0] >= baseValue[1]); |
| dist = distTable[distNdx]; |
| |
| paintR[0] = (uint8_t)deClamp32((int)baseR[0] + dist, 0, 255); |
| paintG[0] = (uint8_t)deClamp32((int)baseG[0] + dist, 0, 255); |
| paintB[0] = (uint8_t)deClamp32((int)baseB[0] + dist, 0, 255); |
| paintR[1] = (uint8_t)deClamp32((int)baseR[0] - dist, 0, 255); |
| paintG[1] = (uint8_t)deClamp32((int)baseG[0] - dist, 0, 255); |
| paintB[1] = (uint8_t)deClamp32((int)baseB[0] - dist, 0, 255); |
| paintR[2] = (uint8_t)deClamp32((int)baseR[1] + dist, 0, 255); |
| paintG[2] = (uint8_t)deClamp32((int)baseG[1] + dist, 0, 255); |
| paintB[2] = (uint8_t)deClamp32((int)baseB[1] + dist, 0, 255); |
| paintR[3] = (uint8_t)deClamp32((int)baseR[1] - dist, 0, 255); |
| paintG[3] = (uint8_t)deClamp32((int)baseG[1] - dist, 0, 255); |
| paintB[3] = (uint8_t)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 uint32_t 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] = (uint8_t)deClamp32((int)paintR[paintNdx], 0, 255); |
| dst[dstOffset + 1] = (uint8_t)deClamp32((int)paintG[paintNdx], 0, 255); |
| dst[dstOffset + 2] = (uint8_t)deClamp32((int)paintB[paintNdx], 0, 255); |
| |
| if (alphaMode) |
| alphaDst[alphaDstOffset] = 255; |
| } |
| } |
| } |
| else |
| { |
| // Planar mode. |
| const uint8_t GO1 = (uint8_t)getBit(src, 56); |
| const uint8_t GO2 = (uint8_t)getBits(src, 49, 54); |
| const uint8_t BO1 = (uint8_t)getBit(src, 48); |
| const uint8_t BO2 = (uint8_t)getBits(src, 43, 44); |
| const uint8_t BO3 = (uint8_t)getBits(src, 39, 41); |
| const uint8_t RH1 = (uint8_t)getBits(src, 34, 38); |
| const uint8_t RH2 = (uint8_t)getBit(src, 32); |
| const uint8_t RO = extend6To8((uint8_t)getBits(src, 57, 62)); |
| const uint8_t GO = extend7To8((uint8_t)((GO1 << 6) | GO2)); |
| const uint8_t BO = extend6To8((uint8_t)((BO1 << 5) | (BO2 << 3) | BO3)); |
| const uint8_t RH = extend6To8((uint8_t)((RH1 << 1) | RH2)); |
| const uint8_t GH = extend7To8((uint8_t)getBits(src, 25, 31)); |
| const uint8_t BH = extend6To8((uint8_t)getBits(src, 19, 24)); |
| const uint8_t RV = extend6To8((uint8_t)getBits(src, 13, 18)); |
| const uint8_t GV = extend7To8((uint8_t)getBits(src, 6, 12)); |
| const uint8_t BV = extend6To8((uint8_t)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] = (uint8_t)deClamp32(unclampedR, 0, 255); |
| dst[dstOffset + 1] = (uint8_t)deClamp32(unclampedG, 0, 255); |
| dst[dstOffset + 2] = (uint8_t)deClamp32(unclampedB, 0, 255); |
| |
| if (alphaMode) |
| alphaDst[alphaDstOffset] = 255; |
| } |
| } |
| } |
| } |
| |
| void decompressEAC8Block(uint8_t dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_A8], uint64_t 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 uint8_t baseCodeword = (uint8_t)getBits(src, 56, 63); |
| const uint8_t multiplier = (uint8_t)getBits(src, 52, 55); |
| const uint32_t 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 uint32_t modifierNdx = |
| (getBit(src, pixelBitNdx + 2) << 2) | (getBit(src, pixelBitNdx + 1) << 1) | getBit(src, pixelBitNdx); |
| const int modifier = modifierTable[tableNdx][modifierNdx]; |
| |
| dst[dstOffset] = (uint8_t)deClamp32((int)baseCodeword + (int)multiplier * modifier, 0, 255); |
| } |
| } |
| |
| void decompressEAC11Block(uint8_t dst[ETC2_UNCOMPRESSED_BLOCK_SIZE_R11], uint64_t 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 int32_t multiplier = (int32_t)getBits(src, 52, 55); |
| const int32_t tableNdx = (int32_t)getBits(src, 48, 51); |
| int32_t baseCodeword = (int32_t)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 uint32_t modifierNdx = |
| (getBit(src, pixelBitNdx + 2) << 2) | (getBit(src, pixelBitNdx + 1) << 1) | getBit(src, pixelBitNdx); |
| const int modifier = modifierTable[tableNdx][modifierNdx]; |
| |
| if (signedMode) |
| { |
| int16_t value; |
| |
| if (multiplier != 0) |
| value = (int16_t)deClamp32(baseCodeword * 8 + multiplier * modifier * 8, -1023, 1023); |
| else |
| value = (int16_t)deClamp32(baseCodeword * 8 + modifier, -1023, 1023); |
| |
| *((int16_t *)(dst + dstOffset)) = value; |
| } |
| else |
| { |
| uint16_t value; |
| |
| if (multiplier != 0) |
| value = (uint16_t)deClamp32(baseCodeword * 8 + 4 + multiplier * modifier * 8, 0, 2047); |
| else |
| value = (uint16_t)deClamp32(baseCodeword * 8 + 4 + modifier, 0, 2047); |
| |
| *((uint16_t *)(dst + dstOffset)) = value; |
| } |
| } |
| } |
| |
| } // namespace EtcDecompressInternal |
| |
| void decompressETC1(const PixelBufferAccess &dst, const uint8_t *src) |
| { |
| using namespace EtcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint64_t compressedBlock = get64BitBlock(src, 0); |
| |
| decompressETC1Block(dstPtr, compressedBlock); |
| } |
| |
| void decompressETC2(const PixelBufferAccess &dst, const uint8_t *src) |
| { |
| using namespace EtcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint64_t compressedBlock = get64BitBlock(src, 0); |
| |
| decompressETC2Block(dstPtr, compressedBlock, NULL, false); |
| } |
| |
| void decompressETC2_EAC_RGBA8(const PixelBufferAccess &dst, const uint8_t *src) |
| { |
| using namespace EtcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const int dstRowPitch = dst.getRowPitch(); |
| const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8; |
| |
| const uint64_t compressedBlockAlpha = get128BitBlockStart(src, 0); |
| const uint64_t compressedBlockRGB = get128BitBlockEnd(src, 0); |
| uint8_t uncompressedBlockAlpha[ETC2_UNCOMPRESSED_BLOCK_SIZE_A8]; |
| uint8_t 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 uint8_t *const srcPixelRGB = |
| &uncompressedBlockRGB[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8]; |
| const uint8_t *const srcPixelAlpha = |
| &uncompressedBlockAlpha[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8]; |
| uint8_t *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 uint8_t *src) |
| { |
| using namespace EtcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const int dstRowPitch = dst.getRowPitch(); |
| const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RGBA8; |
| |
| const uint64_t compressedBlockRGBA = get64BitBlock(src, 0); |
| uint8_t uncompressedBlockRGB[ETC2_UNCOMPRESSED_BLOCK_SIZE_RGB8]; |
| uint8_t uncompressedBlockAlpha[ETC2_UNCOMPRESSED_BLOCK_SIZE_A8]; |
| |
| // Decompress. |
| decompressETC2Block(uncompressedBlockRGB, compressedBlockRGBA, uncompressedBlockAlpha, 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 uint8_t *const srcPixel = |
| &uncompressedBlockRGB[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_RGB8]; |
| const uint8_t *const srcPixelAlpha = |
| &uncompressedBlockAlpha[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_A8]; |
| uint8_t *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 uint8_t *src, bool signedMode) |
| { |
| using namespace EtcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const int dstRowPitch = dst.getRowPitch(); |
| const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_R11; |
| |
| const uint64_t compressedBlock = get64BitBlock(src, 0); |
| uint8_t 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 int16_t *const srcPixel = |
| (int16_t *)&uncompressedBlock[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_R11]; |
| int16_t *const dstPixel = (int16_t *)(dstPtr + y * dstRowPitch + x * dstPixelSize); |
| |
| dstPixel[0] = extend11To16WithSign(srcPixel[0]); |
| } |
| else |
| { |
| const uint16_t *const srcPixel = |
| (uint16_t *)&uncompressedBlock[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_R11]; |
| uint16_t *const dstPixel = (uint16_t *)(dstPtr + y * dstRowPitch + x * dstPixelSize); |
| |
| dstPixel[0] = extend11To16(srcPixel[0]); |
| } |
| } |
| } |
| } |
| |
| void decompressEAC_RG11(const PixelBufferAccess &dst, const uint8_t *src, bool signedMode) |
| { |
| using namespace EtcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const int dstRowPitch = dst.getRowPitch(); |
| const int dstPixelSize = ETC2_UNCOMPRESSED_PIXEL_SIZE_RG11; |
| |
| const uint64_t compressedBlockR = get128BitBlockStart(src, 0); |
| const uint64_t compressedBlockG = get128BitBlockEnd(src, 0); |
| uint8_t uncompressedBlockR[ETC2_UNCOMPRESSED_BLOCK_SIZE_R11]; |
| uint8_t 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 int16_t *const srcPixelR = |
| (int16_t *)&uncompressedBlockR[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_R11]; |
| const int16_t *const srcPixelG = |
| (int16_t *)&uncompressedBlockG[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_R11]; |
| int16_t *const dstPixel = (int16_t *)(dstPtr + y * dstRowPitch + x * dstPixelSize); |
| |
| dstPixel[0] = extend11To16WithSign(srcPixelR[0]); |
| dstPixel[1] = extend11To16WithSign(srcPixelG[0]); |
| } |
| else |
| { |
| const uint16_t *const srcPixelR = |
| (uint16_t *)&uncompressedBlockR[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_R11]; |
| const uint16_t *const srcPixelG = |
| (uint16_t *)&uncompressedBlockG[(y * ETC2_BLOCK_WIDTH + x) * ETC2_UNCOMPRESSED_PIXEL_SIZE_R11]; |
| uint16_t *const dstPixel = (uint16_t *)(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 uint8_t epBits[14] = {10, 7, 11, 11, 11, 9, 8, 8, 8, 6, 10, 11, 12, 16}; |
| |
| static const uint8_t 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 uint8_t 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 uint8_t 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 uint8_t 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 uint8_t 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 uint16_t weights2[4] = {0, 21, 43, 64}; |
| static const uint16_t weights3[8] = {0, 9, 18, 27, 37, 46, 55, 64}; |
| static const uint16_t weights4[16] = {0, 4, 9, 13, 17, 21, 26, 30, 34, 38, 43, 47, 51, 55, 60, 64}; |
| |
| inline float uint8ToFloat(uint8_t src) |
| { |
| return ((float)src / 255.0f); |
| } |
| |
| inline float int8ToFloat(int8_t src) |
| { |
| return ((float)src / 128.0f); |
| } |
| |
| inline uint32_t bgr16torgba32(uint16_t src) |
| { |
| const uint32_t src32 = src; |
| const uint8_t b5 = (src32 & 0x1f); |
| const uint8_t g6 = (src32 >> 5) & 0x3f; |
| const uint8_t r5 = (src32 >> 11) & 0x1f; |
| const uint32_t a8 = 0xff; |
| const uint32_t b8 = extend5To8(b5); |
| const uint32_t g8 = extend6To8(g6); |
| const uint32_t r8 = extend5To8(r5); |
| |
| return (r8 | (g8 << 8) | (b8 << 16) | (a8 << 24)); |
| } |
| |
| // Interpolates color = 1/3 * c0 + 2/3 * c1 |
| inline uint32_t interpolateColor(uint32_t c0, uint32_t c1) |
| { |
| const uint32_t r0 = c0 & 0xff; |
| const uint32_t g0 = (c0 >> 8) & 0xff; |
| const uint32_t b0 = (c0 >> 16) & 0xff; |
| const uint32_t a0 = (c0 >> 24) & 0xff; |
| |
| const uint32_t r1 = c1 & 0xff; |
| const uint32_t g1 = (c1 >> 8) & 0xff; |
| const uint32_t b1 = (c1 >> 16) & 0xff; |
| const uint32_t a1 = (c1 >> 24) & 0xff; |
| |
| const uint32_t r = (r0 + (r1 << 1)) / 3; |
| const uint32_t g = (g0 + (g1 << 1)) / 3; |
| const uint32_t b = (b0 + (b1 << 1)) / 3; |
| const uint32_t a = (a0 + (a1 << 1)) / 3; |
| |
| return (r | (g << 8) | (b << 16) | (a << 24)); |
| } |
| |
| // Average of two colors |
| inline uint32_t averageColor(uint32_t c0, uint32_t c1) |
| { |
| const uint32_t r0 = c0 & 0xff; |
| const uint32_t g0 = (c0 >> 8) & 0xff; |
| const uint32_t b0 = (c0 >> 16) & 0xff; |
| const uint32_t a0 = (c0 >> 24) & 0xff; |
| |
| const uint32_t r1 = c1 & 0xff; |
| const uint32_t g1 = (c1 >> 8) & 0xff; |
| const uint32_t b1 = (c1 >> 16) & 0xff; |
| const uint32_t a1 = (c1 >> 24) & 0xff; |
| |
| const uint32_t r = (r0 + r1) >> 1; |
| const uint32_t g = (g0 + g1) >> 1; |
| const uint32_t b = (b0 + b1) >> 1; |
| const uint32_t a = (a0 + a1) >> 1; |
| |
| return (r | (g << 8) | (b << 16) | (a << 24)); |
| } |
| |
| inline int8_t extractModeBc6(uint8_t 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 (int8_t)(2 + ((src >> 2) & 0x7)); |
| case 3: |
| return (int8_t)(10 + ((src >> 2) & 0x7)); |
| } |
| |
| return -1; |
| } |
| |
| inline int8_t extractModeBc7(uint8_t src) |
| { |
| for (int8_t i = 0; i < 8; i++) |
| if (src & (1 << i)) |
| return i; |
| |
| return -1; |
| } |
| |
| inline uint64_t get64BitBlockLE(const uint8_t *src, int blockNdx) |
| { |
| // Same as get64BitBlock, but little-endian. |
| uint64_t block = 0; |
| |
| for (int i = 0; i < 8; i++) |
| block |= (uint64_t)(src[blockNdx * 8 + i]) << (8ull * i); |
| |
| return block; |
| } |
| |
| inline uint32_t getBits128(uint64_t low, uint64_t high, uint32_t first, uint32_t last) |
| { |
| const uint64_t d[2] = {low, high}; |
| const bool reverse = first > last; |
| uint32_t ret = 0; |
| |
| if (reverse) |
| { |
| const uint32_t 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 uint32_t shift = first % 64; |
| const uint32_t len = last - first + 1; |
| const uint32_t mask = (1 << len) - 1; |
| ret = (uint32_t)((d[elementFirst] >> shift) & mask); |
| } |
| else |
| { |
| // Bits contained in both of the 64bit elements |
| DE_ASSERT(last > 63); |
| DE_ASSERT(first < 64); |
| const uint32_t len0 = 64 - first; |
| const uint32_t mask0 = (1 << len0) - 1; |
| const uint32_t data0 = (uint32_t)(low >> first) & mask0; |
| const uint32_t len1 = last - 63; |
| const uint32_t mask1 = (1 << len1) - 1; |
| const uint32_t data1 = (uint32_t)(high & mask1); |
| ret = (uint32_t)((data1 << len0) | data0); |
| } |
| |
| if (reverse) |
| { |
| const uint32_t len = last - first + 1; |
| const uint32_t orig = ret; |
| ret = 0; |
| |
| for (uint32_t i = 0; i < len; i++) |
| { |
| ret |= ((orig >> (len - 1 - i)) & 1) << i; |
| } |
| } |
| |
| return ret; |
| } |
| |
| inline int32_t signExtend(int32_t value, int32_t srcBits, int32_t dstBits) |
| { |
| uint32_t sign = value & (1 << (srcBits - 1)); |
| |
| if (!sign) |
| return value; |
| |
| int32_t dstMask = (int32_t)(((uint64_t)1 << dstBits) - 1); |
| int32_t extendedBits = 0xffffffff << srcBits; |
| return (value | extendedBits) & dstMask; |
| } |
| |
| inline int32_t unquantize(int32_t 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 >= (((int32_t)1 << (epBits[mode] - 1)) - 1)) |
| x = 0x7fff; |
| else |
| x = (((int32_t)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 == (((int32_t)1 << epBits[mode]) - 1)) |
| return 0xffff; |
| else |
| return ((((int32_t)x << 15) + 0x4000) >> (epBits[mode] - 1)); |
| } |
| } |
| |
| inline int32_t interpolate(int32_t a, int32_t b, uint32_t index, uint32_t indexPrecision) |
| { |
| const uint16_t *weights[] = {weights2, weights3, weights4}; |
| const uint16_t *weight = weights[indexPrecision - 2]; |
| DE_ASSERT(indexPrecision >= 2 && indexPrecision <= 4); |
| |
| return (((64 - weight[index]) * a + weight[index] * b + 32) >> 6); |
| } |
| |
| inline int16_t finishUnquantize(int32_t 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 (int16_t)x; |
| } |
| |
| } // namespace BcDecompressInternal |
| |
| void decompressBc1(const PixelBufferAccess &dst, const uint8_t *src, bool hasAlpha) |
| { |
| using namespace BcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint32_t dstRowPitch = dst.getRowPitch(); |
| const uint32_t dstPixelSize = 4; |
| const uint16_t color0_16 = ((uint16_t *)src)[0]; |
| const uint16_t color1_16 = ((uint16_t *)src)[1]; |
| const uint32_t color0 = bgr16torgba32(color0_16); |
| const uint32_t color1 = bgr16torgba32(color1_16); |
| const uint8_t *const indices8 = &src[4]; |
| |
| const bool alphaMode = color1_16 > color0_16; |
| |
| const int32_t 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 uint32_t colors[4] = {color0, color1, |
| alphaMode ? averageColor(color0, color1) : interpolateColor(color1, color0), |
| alphaMode ? (hasAlpha ? 0 : 0xff000000) : interpolateColor(color0, color1)}; |
| |
| for (uint32_t y = 0; y < (uint32_t)BC_BLOCK_HEIGHT; y++) |
| { |
| for (uint32_t x = 0; x < (uint32_t)BC_BLOCK_WIDTH; x++) |
| { |
| uint32_t *const dstPixel = (uint32_t *)(dstPtr + y * dstRowPitch + x * dstPixelSize); |
| *dstPixel = colors[indices[y * BC_BLOCK_WIDTH + x]]; |
| } |
| } |
| } |
| |
| void decompressBc2(const PixelBufferAccess &dst, const uint8_t *src) |
| { |
| using namespace BcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint32_t dstRowPitch = dst.getRowPitch(); |
| const uint32_t dstPixelSize = 4; |
| const uint16_t color0_16 = ((uint16_t *)src)[4]; |
| const uint16_t color1_16 = ((uint16_t *)src)[5]; |
| const uint32_t color0 = bgr16torgba32(color0_16); |
| const uint32_t color1 = bgr16torgba32(color1_16); |
| const uint8_t *const indices8 = &src[12]; |
| const uint8_t *const alphas8 = src; |
| |
| const int32_t 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 int32_t 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 uint32_t colors[4] = {color0, color1, interpolateColor(color1, color0), interpolateColor(color0, color1)}; |
| |
| for (uint32_t y = 0; y < (uint32_t)BC_BLOCK_HEIGHT; y++) |
| { |
| for (uint32_t x = 0; x < (uint32_t)BC_BLOCK_WIDTH; x++) |
| { |
| uint32_t *const dstPixel = (uint32_t *)(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 uint8_t *src) |
| { |
| using namespace BcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint32_t dstRowPitch = dst.getRowPitch(); |
| const uint32_t dstPixelSize = 4; |
| const uint8_t alpha0 = src[0]; |
| const uint8_t alpha1 = src[1]; |
| const uint16_t color0_16 = ((uint16_t *)src)[4]; |
| const uint16_t color1_16 = ((uint16_t *)src)[5]; |
| const uint32_t color0 = bgr16torgba32(color0_16); |
| const uint32_t color1 = bgr16torgba32(color1_16); |
| const uint8_t *const indices8 = &src[12]; |
| const uint64_t alphaBits = get64BitBlockLE(src, 0) >> 16; |
| uint32_t alphas[8]; |
| |
| const int32_t 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 int32_t alphaIndices[16] = { |
| (int32_t)((alphaBits >> 0) & 0x7), (int32_t)((alphaBits >> 3) & 0x7), (int32_t)((alphaBits >> 6) & 0x7), |
| (int32_t)((alphaBits >> 9) & 0x7), (int32_t)((alphaBits >> 12) & 0x7), (int32_t)((alphaBits >> 15) & 0x7), |
| (int32_t)((alphaBits >> 18) & 0x7), (int32_t)((alphaBits >> 21) & 0x7), (int32_t)((alphaBits >> 24) & 0x7), |
| (int32_t)((alphaBits >> 27) & 0x7), (int32_t)((alphaBits >> 30) & 0x7), (int32_t)((alphaBits >> 33) & 0x7), |
| (int32_t)((alphaBits >> 36) & 0x7), (int32_t)((alphaBits >> 39) & 0x7), (int32_t)((alphaBits >> 42) & 0x7), |
| (int32_t)((alphaBits >> 45) & 0x7)}; |
| |
| const uint32_t colors[4] = {color0, color1, interpolateColor(color1, color0), interpolateColor(color0, color1)}; |
| |
| alphas[0] = alpha0 << 24; |
| alphas[1] = alpha1 << 24; |
| |
| if (alpha0 > alpha1) |
| { |
| for (uint32_t i = 0; i < 6; i++) |
| alphas[i + 2] = (((uint32_t)alpha0 * (6 - i) + (uint32_t)alpha1 * (1 + i)) / 7) << 24; |
| } |
| else |
| { |
| for (uint32_t i = 0; i < 4; i++) |
| alphas[i + 2] = (((uint32_t)alpha0 * (4 - i) + (uint32_t)alpha1 * (1 + i)) / 5) << 24; |
| alphas[6] = 0; |
| alphas[7] = 0xff000000; |
| } |
| |
| for (uint32_t y = 0; y < (uint32_t)BC_BLOCK_HEIGHT; y++) |
| { |
| for (uint32_t x = 0; x < (uint32_t)BC_BLOCK_WIDTH; x++) |
| { |
| uint32_t *const dstPixel = (uint32_t *)(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 uint8_t *src, bool hasSign) |
| { |
| using namespace BcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint32_t dstRowPitch = dst.getRowPitch(); |
| const uint32_t dstPixelSize = 4; |
| const uint8_t red0 = src[0]; |
| const uint8_t red1 = src[1]; |
| const int8_t red0s = ((int8_t *)src)[0]; |
| const int8_t red1s = ((int8_t *)src)[1]; |
| const uint64_t indexBits = get64BitBlockLE(src, 0) >> 16; |
| float reds[8]; |
| |
| const int32_t indices[16] = { |
| (int32_t)((indexBits >> 0) & 0x7), (int32_t)((indexBits >> 3) & 0x7), (int32_t)((indexBits >> 6) & 0x7), |
| (int32_t)((indexBits >> 9) & 0x7), (int32_t)((indexBits >> 12) & 0x7), (int32_t)((indexBits >> 15) & 0x7), |
| (int32_t)((indexBits >> 18) & 0x7), (int32_t)((indexBits >> 21) & 0x7), (int32_t)((indexBits >> 24) & 0x7), |
| (int32_t)((indexBits >> 27) & 0x7), (int32_t)((indexBits >> 30) & 0x7), (int32_t)((indexBits >> 33) & 0x7), |
| (int32_t)((indexBits >> 36) & 0x7), (int32_t)((indexBits >> 39) & 0x7), (int32_t)((indexBits >> 42) & 0x7), |
| (int32_t)((indexBits >> 45) & 0x7)}; |
| |
| reds[0] = hasSign ? int8ToFloat(red0s) : uint8ToFloat(red0); |
| reds[1] = hasSign ? int8ToFloat(red1s) : uint8ToFloat(red1); |
| |
| if (reds[0] > reds[1]) |
| { |
| for (uint32_t i = 0; i < 6; i++) |
| reds[i + 2] = (reds[0] * (6.0f - (float)i) + reds[1] * (1.0f + (float)i)) / 7.0f; |
| } |
| else |
| { |
| for (uint32_t 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 (uint32_t y = 0; y < (uint32_t)BC_BLOCK_HEIGHT; y++) |
| { |
| for (uint32_t x = 0; x < (uint32_t)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 uint8_t *src, bool hasSign) |
| { |
| using namespace BcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint32_t dstRowPitch = dst.getRowPitch(); |
| const uint32_t dstPixelSize = 8; |
| float rg[2][8]; |
| uint32_t indices[2][16]; |
| |
| for (uint32_t c = 0; c < 2; c++) |
| { |
| const uint32_t offset = c * 8; |
| const uint8_t rg0 = src[offset]; |
| const uint8_t rg1 = src[offset + 1]; |
| const int8_t rg0s = ((int8_t *)src)[offset]; |
| const int8_t rg1s = ((int8_t *)src)[offset + 1]; |
| const uint64_t indexBits = get64BitBlockLE(src, c) >> 16; |
| |
| for (uint32_t 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 (uint32_t 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 (uint32_t 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 (uint32_t y = 0; y < (uint32_t)BC_BLOCK_HEIGHT; y++) |
| { |
| for (uint32_t x = 0; x < (uint32_t)BC_BLOCK_WIDTH; x++) |
| { |
| float *const dstPixel = (float *)(dstPtr + y * dstRowPitch + x * dstPixelSize); |
| for (uint32_t i = 0; i < 2; i++) |
| dstPixel[i] = rg[i][indices[i][y * BC_BLOCK_WIDTH + x]]; |
| } |
| } |
| } |
| |
| void decompressBc6H(const PixelBufferAccess &dst, const uint8_t *src, bool hasSign) |
| { |
| using namespace BcDecompressInternal; |
| |
| uint8_t *const dstPtr = (uint8_t *)dst.getDataPtr(); |
| const uint32_t dstRowPitch = dst.getRowPitch(); |
| const uint32_t dstPixelSize = 6; |
| |
| int32_t mode = extractModeBc6(src[0]); |
| IVec4 r(0); |
| IVec4 g(0); |
| IVec4 b(0); |
| uint32_t deltaBitsR = 0; |
| uint32_t deltaBitsG = 0; |
| uint32_t deltaBitsB = 0; |
| const uint64_t low = ((uint64_t *)src)[0]; |
| const uint64_t high = ((uint64_t *)src)[1]; |
| const uint32_t d = mode < 10 ? getBits128(low, high, 77, 81) : 0; |
| const uint32_t numRegions = mode > 9 ? 1 : 2; |
| const uint32_t numEndpoints = numRegions * 2; |
| const bool transformed = mode != 9 && mode != 10; |
| const uint32_t colorIndexBC = mode < 10 ? 3 : 4; |
| uint64_t colorIndexData = high >> (mode < 10 ? 18 : 1); |
| const uint32_t 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
|