// Copyright 2019 The SwiftShader Authors. All Rights Reserved.
//
// 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.

#include "BC_Decoder.hpp"

#include "System/Debug.hpp"
#include "System/Math.hpp"

#include <algorithm>
#include <array>
#include <cstddef>
#include <vector>

#include <assert.h>
#include <stdint.h>

namespace {
static constexpr int BlockWidth = 4;
static constexpr int BlockHeight = 4;

struct BC_color
{
	void decode(uint8_t *dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, bool hasAlphaChannel, bool hasSeparateAlpha) const
	{
		Color c[4];
		c[0].extract565(c0);
		c[1].extract565(c1);
		if(hasSeparateAlpha || (c0 > c1))
		{
			c[2] = ((c[0] * 2) + c[1]) / 3;
			c[3] = ((c[1] * 2) + c[0]) / 3;
		}
		else
		{
			c[2] = (c[0] + c[1]) >> 1;
			if(hasAlphaChannel)
			{
				c[3].clearAlpha();
			}
		}

		for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
		{
			int dstOffset = j * dstPitch;
			int idxOffset = j * BlockHeight;
			for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, idxOffset++, dstOffset += dstBpp)
			{
				*reinterpret_cast<unsigned int *>(dst + dstOffset) = c[getIdx(idxOffset)].pack8888();
			}
		}
	}

private:
	struct Color
	{
		Color()
		{
			c[0] = c[1] = c[2] = 0;
			c[3] = 0xFF000000;
		}

		void extract565(const unsigned int c565)
		{
			c[0] = ((c565 & 0x0000001F) << 3) | ((c565 & 0x0000001C) >> 2);
			c[1] = ((c565 & 0x000007E0) >> 3) | ((c565 & 0x00000600) >> 9);
			c[2] = ((c565 & 0x0000F800) >> 8) | ((c565 & 0x0000E000) >> 13);
		}

		unsigned int pack8888() const
		{
			return ((c[2] & 0xFF) << 16) | ((c[1] & 0xFF) << 8) | (c[0] & 0xFF) | c[3];
		}

		void clearAlpha()
		{
			c[3] = 0;
		}

		Color operator*(int factor) const
		{
			Color res;
			for(int i = 0; i < 4; ++i)
			{
				res.c[i] = c[i] * factor;
			}
			return res;
		}

		Color operator/(int factor) const
		{
			Color res;
			for(int i = 0; i < 4; ++i)
			{
				res.c[i] = c[i] / factor;
			}
			return res;
		}

		Color operator>>(int shift) const
		{
			Color res;
			for(int i = 0; i < 4; ++i)
			{
				res.c[i] = c[i] >> shift;
			}
			return res;
		}

		Color operator+(Color const &obj) const
		{
			Color res;
			for(int i = 0; i < 4; ++i)
			{
				res.c[i] = c[i] + obj.c[i];
			}
			return res;
		}

	private:
		int c[4];
	};

	unsigned int getIdx(int i) const
	{
		int offset = i << 1;  // 2 bytes per index
		return (idx & (0x3 << offset)) >> offset;
	}

	unsigned short c0;
	unsigned short c1;
	unsigned int idx;
};

struct BC_channel
{
	void decode(uint8_t *dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp, int channel, bool isSigned) const
	{
		int c[8] = { 0 };

		if(isSigned)
		{
			c[0] = static_cast<signed char>(data & 0xFF);
			c[1] = static_cast<signed char>((data & 0xFF00) >> 8);
		}
		else
		{
			c[0] = static_cast<uint8_t>(data & 0xFF);
			c[1] = static_cast<uint8_t>((data & 0xFF00) >> 8);
		}

		if(c[0] > c[1])
		{
			for(int i = 2; i < 8; ++i)
			{
				c[i] = ((8 - i) * c[0] + (i - 1) * c[1]) / 7;
			}
		}
		else
		{
			for(int i = 2; i < 6; ++i)
			{
				c[i] = ((6 - i) * c[0] + (i - 1) * c[1]) / 5;
			}
			c[6] = isSigned ? -128 : 0;
			c[7] = isSigned ? 127 : 255;
		}

		for(int j = 0; j < BlockHeight && (y + j) < dstH; j++)
		{
			for(int i = 0; i < BlockWidth && (x + i) < dstW; i++)
			{
				dst[channel + (i * dstBpp) + (j * dstPitch)] = static_cast<uint8_t>(c[getIdx((j * BlockHeight) + i)]);
			}
		}
	}

private:
	uint8_t getIdx(int i) const
	{
		int offset = i * 3 + 16;
		return static_cast<uint8_t>((data & (0x7ull << offset)) >> offset);
	}

	uint64_t data;
};

struct BC_alpha
{
	void decode(uint8_t *dst, int x, int y, int dstW, int dstH, int dstPitch, int dstBpp) const
	{
		dst += 3;  // Write only to alpha (channel 3)
		for(int j = 0; j < BlockHeight && (y + j) < dstH; j++, dst += dstPitch)
		{
			uint8_t *dstRow = dst;
			for(int i = 0; i < BlockWidth && (x + i) < dstW; i++, dstRow += dstBpp)
			{
				*dstRow = getAlpha(j * BlockHeight + i);
			}
		}
	}

private:
	uint8_t getAlpha(int i) const
	{
		int offset = i << 2;
		int alpha = (data & (0xFull << offset)) >> offset;
		return static_cast<uint8_t>(alpha | (alpha << 4));
	}

	uint64_t data;
};

namespace BC6H {

static constexpr int MaxPartitions = 64;

static constexpr uint8_t PartitionTable2[MaxPartitions][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 constexpr uint8_t AnchorTable2[MaxPartitions] = {
	// clang-format off
	0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf,
	0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf,
	0xf, 0x2, 0x8, 0x2, 0x2, 0x8, 0x8, 0xf,
	0x2, 0x8, 0x2, 0x2, 0x8, 0x8, 0x2, 0x2,
	0xf, 0xf, 0x6, 0x8, 0x2, 0x8, 0xf, 0xf,
	0x2, 0x8, 0x2, 0x2, 0x2, 0xf, 0xf, 0x6,
	0x6, 0x2, 0x6, 0x8, 0xf, 0xf, 0x2, 0x2,
	0xf, 0xf, 0xf, 0xf, 0xf, 0x2, 0x2, 0xf,
	// clang-format on
};

// 1.0f in half-precision floating point format
static constexpr uint16_t halfFloat1 = 0x3C00;
union Color
{
	struct RGBA
	{
		uint16_t r = 0;
		uint16_t g = 0;
		uint16_t b = 0;
		const uint16_t a = halfFloat1;

		RGBA(uint16_t r, uint16_t g, uint16_t b)
		    : r(r)
		    , g(g)
		    , b(b)
		{
		}

		RGBA &operator=(const RGBA &other)
		{
			if(this != &other)
			{
				this->r = other.r;
				this->g = other.g;
				this->b = other.b;
			}

			return *this;
		}
	};

	Color(uint16_t r, uint16_t g, uint16_t b)
	    : rgba(r, g, b)
	{
	}

	Color(int r, int g, int b)
	    : rgba((uint16_t)r, (uint16_t)g, (uint16_t)b)
	{
	}

	Color()
	{
	}

	Color &operator=(const Color &other)
	{
		if(this != &other)
		{
			this->rgba = other.rgba;
		}
		return *this;
	}

	RGBA rgba;
	uint16_t channel[4];
};
static_assert(sizeof(Color) == 8, "BC6h::Color must be 8 bytes long");

inline int32_t extendSign(int32_t val, size_t size)
{
	// Suppose we have a 2-bit integer being stored in 4 bit variable:
	//    x = 0b00AB
	//
	// In order to sign extend x, we need to turn the 0s into A's:
	//    x_extend = 0bAAAB
	//
	// We can do that by flipping A in x then subtracting 0b0010 from x.
	// Suppose A is 1:
	//    x       = 0b001B
	//    x_flip  = 0b000B
	//    x_minus = 0b111B
	// Since A is flipped to 0, subtracting the mask sets it and all the bits above it to 1.
	// And if A is 0:
	//    x       = 0b000B
	//    x_flip  = 0b001B
	//    x_minus = 0b000B
	// We unset the bit we flipped, and touch no other bit
	uint16_t mask = 1u << (size - 1);
	return (val ^ mask) - mask;
}

static int constexpr RGBfChannels = 3;
struct RGBf
{
	uint16_t channel[RGBfChannels];
	size_t size[RGBfChannels];
	bool isSigned;

	RGBf()
	{
		static_assert(RGBfChannels == 3, "RGBf must have exactly 3 channels");
		static_assert(sizeof(channel) / sizeof(channel[0]) == RGBfChannels, "RGBf must have exactly 3 channels");
		static_assert(sizeof(channel) / sizeof(channel[0]) == sizeof(size) / sizeof(size[0]), "RGBf requires equally sized arrays for channels and channel sizes");

		for(int i = 0; i < RGBfChannels; i++)
		{
			channel[i] = 0;
			size[i] = 0;
		}

		isSigned = false;
	}

	void extendSign()
	{
		for(int i = 0; i < RGBfChannels; i++)
		{
			channel[i] = BC6H::extendSign(channel[i], size[i]);
		}
	}

	// Assuming this is the delta, take the base-endpoint and transform this into
	// a proper endpoint.
	//
	// The final computed endpoint is truncated to the base-endpoint's size;
	void resolveDelta(RGBf base)
	{
		for(int i = 0; i < RGBfChannels; i++)
		{
			size[i] = base.size[i];
			channel[i] = (base.channel[i] + channel[i]) & ((1 << base.size[i]) - 1);
		}

		// Per the spec:
		// "For signed formats, the results of the delta calculation must be sign
		// extended as well."
		if(isSigned)
		{
			extendSign();
		}
	}

	void unquantize()
	{
		if(isSigned)
		{
			unquantizeSigned();
		}
		else
		{
			unquantizeUnsigned();
		}
	}

	void unquantizeUnsigned()
	{
		for(int i = 0; i < RGBfChannels; i++)
		{
			if(size[i] >= 15 || channel[i] == 0)
			{
				continue;
			}
			else if(channel[i] == ((1u << size[i]) - 1))
			{
				channel[i] = 0xFFFFu;
			}
			else
			{
				// Need 32 bits to avoid overflow
				uint32_t tmp = channel[i];
				channel[i] = (uint16_t)(((tmp << 16) + 0x8000) >> size[i]);
			}
			size[i] = 16;
		}
	}

	void unquantizeSigned()
	{
		for(int i = 0; i < RGBfChannels; i++)
		{
			if(size[i] >= 16 || channel[i] == 0)
			{
				continue;
			}

			int16_t value = sw::bit_cast<int16_t>(channel[i]);
			int32_t result = value;
			bool signBit = value < 0;
			if(signBit)
			{
				value = -value;
			}

			if(value >= ((1 << (size[i] - 1)) - 1))
			{
				result = 0x7FFF;
			}
			else
			{
				// Need 32 bits to avoid overflow
				int32_t tmp = value;
				result = (((tmp << 15) + 0x4000) >> (size[i] - 1));
			}

			if(signBit)
			{
				result = -result;
			}

			channel[i] = (uint16_t)result;
			size[i] = 16;
		}
	}
};

struct Data
{
	uint64_t low64;
	uint64_t high64;

	Data() = default;
	Data(uint64_t low64, uint64_t high64)
	    : low64(low64)
	    , high64(high64)
	{
	}

	// Consumes the lowest N bits from from low64 and high64 where N is:
	//      abs(MSB - LSB)
	// MSB and LSB come from the block description of the BC6h spec and specify
	// the location of the bits in the returned bitstring.
	//
	// If MSB < LSB, then the bits are reversed. Otherwise, the bitstring is read and
	// shifted without further modification.
	//
	uint32_t consumeBits(uint32_t MSB, uint32_t LSB)
	{
		bool reversed = MSB < LSB;
		if(reversed)
		{
			std::swap(MSB, LSB);
		}
		ASSERT(MSB - LSB + 1 < sizeof(uint32_t) * 8);

		uint32_t numBits = MSB - LSB + 1;
		uint32_t mask = (1 << numBits) - 1;
		// Read the low N bits
		uint32_t bits = (low64 & mask);

		low64 >>= numBits;
		// Put the low N bits of high64 into the high 64-N bits of low64
		low64 |= (high64 & mask) << (sizeof(high64) * 8 - numBits);
		high64 >>= numBits;

		if(reversed)
		{
			uint32_t tmp = 0;
			for(uint32_t numSwaps = 0; numSwaps < numBits; numSwaps++)
			{
				tmp <<= 1;
				tmp |= (bits & 1);
				bits >>= 1;
			}

			bits = tmp;
		}

		return bits << LSB;
	}
};

struct IndexInfo
{
	uint64_t value;
	int numBits;
};

// Interpolates between two endpoints, then does a final unquantization step
Color interpolate(RGBf e0, RGBf e1, const IndexInfo &index, bool isSigned)
{
	static constexpr uint32_t weights3[] = { 0, 9, 18, 27, 37, 46, 55, 64 };
	static constexpr uint32_t weights4[] = { 0, 4, 9, 13, 17, 21, 26, 30,
		                                     34, 38, 43, 47, 51, 55, 60, 64 };
	static constexpr uint32_t const *weightsN[] = {
		nullptr, nullptr, nullptr, weights3, weights4
	};
	auto weights = weightsN[index.numBits];
	ASSERT_MSG(weights != nullptr, "Unexpected number of index bits: %d", (int)index.numBits);
	Color color;
	uint32_t e0Weight = 64 - weights[index.value];
	uint32_t e1Weight = weights[index.value];

	for(int i = 0; i < RGBfChannels; i++)
	{
		int32_t e0Channel = e0.channel[i];
		int32_t e1Channel = e1.channel[i];

		if(isSigned)
		{
			e0Channel = extendSign(e0Channel, 16);
			e1Channel = extendSign(e1Channel, 16);
		}

		int32_t e0Value = e0Channel * e0Weight;
		int32_t e1Value = e1Channel * e1Weight;

		uint32_t tmp = ((e0Value + e1Value + 32) >> 6);

		// Need to unquantize value to limit it to the legal range of half-precision
		// floats. We do this by scaling by 31/32 or 31/64 depending on if the value
		// is signed or unsigned.
		if(isSigned)
		{
			tmp = ((tmp & 0x80000000) != 0) ? (((~tmp + 1) * 31) >> 5) | 0x8000 : (tmp * 31) >> 5;
			// Don't return -0.0f, just normalize it to 0.0f.
			if(tmp == 0x8000)
				tmp = 0;
		}
		else
		{
			tmp = (tmp * 31) >> 6;
		}

		color.channel[i] = (uint16_t)tmp;
	}

	return color;
}

enum DataType
{
	// Endpoints
	EP0 = 0,
	EP1 = 1,
	EP2 = 2,
	EP3 = 3,
	Mode,
	Partition,
};

enum Channel
{
	R = 0,
	G = 1,
	B = 2,
	None,
};

struct DeltaBits
{
	size_t channel[3];

	DeltaBits()
	{
		channel[R] = 0;
		channel[G] = 0;
		channel[B] = 0;
	}

	DeltaBits(int r, int g, int b)
	{
		channel[R] = r;
		channel[G] = g;
		channel[B] = b;
	}
};

struct ModeDesc
{
	int number;
	bool hasDelta;
	int partitionCount;
	int endpointBits;
	int numEndpoints;
	DeltaBits deltaBits;

	ModeDesc()
	    : number(-1)
	    , hasDelta(false)
	    , partitionCount(0)
	    , endpointBits(0)
	    , numEndpoints(0)
	{
	}

	ModeDesc(int number, bool hasDelta, int partitionCount, int endpointBits, DeltaBits deltaBits)
	    : number(number)
	    , hasDelta(hasDelta)
	    , partitionCount(partitionCount)
	    , endpointBits(endpointBits)
	    , deltaBits(deltaBits)
	{
		numEndpoints = partitionCount * 2;
	}
};

struct BlockDesc
{
	DataType type;
	Channel channel;
	int MSB;
	int LSB;
	ModeDesc modeDesc;

	BlockDesc() = default;

	BlockDesc(DataType type, Channel channel, int MSB, int LSB, ModeDesc modeDesc)
	    : type(type)
	    , channel(channel)
	    , MSB(MSB)
	    , LSB(LSB)
	    , modeDesc(modeDesc)
	{
	}

	BlockDesc(DataType type, Channel channel, int MSB, int LSB)
	    : type(type)
	    , channel(channel)
	    , MSB(MSB)
	    , LSB(LSB)
	{
	}
};

// Table describing the bitfields for each mode from the LSB to the MSB before
// the index data starts.
//
// The numbers come from the BC6h block description. The basic format is a list of bitfield
// descriptors of the form:
//   {Type, Channel, MSB, LSB}
//   * Type describes which endpoint this is, or if this is a mode or a partition number.
//   * Channel describes one of the 3 color channels within an endpoint
//   * MSB and LSB specificy:
//      * The size of the bitfield being read
//      * The position of the bitfield within the variable it is being read to
//      * And if the bitfield is stored in reverse bit order
//     If MSB < LSB then the bitfield is stored in reverse order. The size of the bitfield
//     is abs(MSB-LSB+1). And the position of the bitfield within the variable is
//     min(LSB, MSB).
//
// Invalid or reserved modes do not have any fields within them.
static const std::vector<BlockDesc> blockDescs[32] = {
	// clang-format off
	// Mode 0
	{ { Mode, None, 1, 0, { 0, true, 2, 10, { 5, 5, 5 } } },
	  { EP2, G, 4, 4 }, { EP2, B, 4, 4 }, { EP3, B, 4, 4 },
	  { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	  { EP1, R, 4, 0 }, { EP3, G, 4, 4 }, { EP2, G, 3, 0 },
	  { EP1, G, 4, 0 }, { EP3, B, 0, 0 }, { EP3, G, 3, 0 },
	  { EP1, B, 4, 0 }, { EP3, B, 1, 1 }, { EP2, B, 3, 0 },
	  { EP2, R, 4, 0 }, { EP3, B, 2, 2 }, { EP3, R, 4, 0 },
	  { EP3, B, 3, 3 },
	  { Partition, None, 4, 0 } },
	// Mode 1
	{ { Mode, None, 1, 0, { 1, true, 2, 7, { 6, 6, 6 } } },
	  { EP2, G, 5, 5 }, { EP3, G, 5, 4 }, { EP0, R, 6, 0 },
	  { EP3, B, 1, 0 }, { EP2, B, 4, 4 }, { EP0, G, 6, 0 },
	  { EP2, B, 5, 5 }, { EP3, B, 2, 2 }, { EP2, G, 4, 4 },
	  { EP0, B, 6, 0 }, { EP3, B, 3, 3 }, { EP3, B, 5, 5 },
      { EP3, B, 4, 4 }, { EP1, R, 5, 0 }, { EP2, G, 3, 0 },
      { EP1, G, 5, 0 }, { EP3, G, 3, 0 }, { EP1, B, 5, 0 },
      { EP2, B, 3, 0 }, { EP2, R, 5, 0 }, { EP3, R, 5, 0 },
	  { Partition, None, 4, 0 } },
	// Mode 2
	{ { Mode, None, 4, 0, { 2, true, 2, 11, { 5, 4, 4 } } },
	  { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	  { EP1, R, 4, 0 }, { EP0, R, 10, 10 }, { EP2, G, 3, 0 },
	  { EP1, G, 3, 0 }, { EP0, G, 10, 10 }, { EP3, B, 0, 0 },
	  { EP3, G, 3, 0 }, { EP1, B, 3, 0 }, { EP0, B, 10, 10 },
	  { EP3, B, 1, 1 }, { EP2, B, 3, 0 }, { EP2, R, 4, 0 },
	  { EP3, B, 2, 2 }, { EP3, R, 4, 0 }, { EP3, B, 3, 3 },
	  { Partition, None, 4, 0 } },
	// Mode 3
	{
	    { Mode, None, 4, 0, { 3, false, 1, 10, { 0, 0, 0 } } },
	    { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	    { EP1, R, 9, 0 }, { EP1, G, 9, 0 }, { EP1, B, 9, 0 },
	},
	// Mode 4: Illegal
	{},
	// Mode 5: Illegal
	{},
	// Mode 6
	{ { Mode, None, 4, 0, { 6, true, 2, 11, { 4, 5, 4 } } },
	  { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	  { EP1, R, 3, 0 }, { EP0, R, 10, 10 }, { EP3, G, 4, 4 },
	  { EP2, G, 3, 0 }, { EP1, G, 4, 0 }, { EP0, G, 10, 10 },
	  { EP3, G, 3, 0 }, { EP1, B, 3, 0 }, { EP0, B, 10, 10 },
	  { EP3, B, 1, 1 }, { EP2, B, 3, 0 }, { EP2, R, 3, 0 },
	  { EP3, B, 0, 0 }, { EP3, B, 2, 2 }, { EP3, R, 3, 0 },
	  { EP2, G, 4, 4 }, { EP3, B, 3, 3 },
	  { Partition, None, 4, 0 } },
	// Mode 7
	{
	    { Mode, None, 4, 0, { 7, true, 1, 11, { 9, 9, 9 } } },
	    { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	    { EP1, R, 8, 0 }, { EP0, R, 10, 10 }, { EP1, G, 8, 0 },
	    { EP0, G, 10, 10 }, { EP1, B, 8, 0 }, { EP0, B, 10, 10 },
	},
	// Mode 8: Illegal
	{},
	// Mode 9: Illegal
	{},
	// Mode 10
	{ { Mode, None, 4, 0, { 10, true, 2, 11, { 4, 4, 5 } } },
	  { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	  { EP1, R, 3, 0 }, { EP0, R, 10, 10 }, { EP2, B, 4, 4 },
	  { EP2, G, 3, 0 }, { EP1, G, 3, 0 }, { EP0, G, 10, 10 },
	  { EP3, B, 0, 0 }, { EP3, G, 3, 0 }, { EP1, B, 4, 0 },
	  { EP0, B, 10, 10 }, { EP2, B, 3, 0 }, { EP2, R, 3, 0 },
	  { EP3, B, 1, 1 }, { EP3, B, 2, 2 }, { EP3, R, 3, 0 },
      { EP3, B, 4, 4 }, { EP3, B, 3, 3 },
	  { Partition, None, 4, 0 } },
	// Mode 11
	{
	    { Mode, None, 4, 0, { 11, true, 1, 12, { 8, 8, 8 } } },
	    { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	    { EP1, R, 7, 0 }, { EP0, R, 10, 11 }, { EP1, G, 7, 0 },
	    { EP0, G, 10, 11 }, { EP1, B, 7, 0 }, { EP0, B, 10, 11 },
	},
	// Mode 12: Illegal
	{},
	// Mode 13: Illegal
	{},
	// Mode 14
	{ { Mode, None, 4, 0, { 14, true, 2, 9, { 5, 5, 5 } } },
	  { EP0, R, 8, 0 }, { EP2, B, 4, 4 }, { EP0, G, 8, 0 },
	  { EP2, G, 4, 4 }, { EP0, B, 8, 0 }, { EP3, B, 4, 4 },
	  { EP1, R, 4, 0 }, { EP3, G, 4, 4 }, { EP2, G, 3, 0 },
	  { EP1, G, 4, 0 }, { EP3, B, 0, 0 }, { EP3, G, 3, 0 },
	  { EP1, B, 4, 0 }, { EP3, B, 1, 1 }, { EP2, B, 3, 0 },
	  { EP2, R, 4, 0 }, { EP3, B, 2, 2 }, { EP3, R, 4, 0 },
	  { EP3, B, 3, 3 },
	  { Partition, None, 4, 0 } },
	// Mode 15
	{
	    { Mode, None, 4, 0, { 15, true, 1, 16, { 4, 4, 4 } } },
	    { EP0, R, 9, 0 }, { EP0, G, 9, 0 }, { EP0, B, 9, 0 },
	    { EP1, R, 3, 0 }, { EP0, R, 10, 15 }, { EP1, G, 3, 0 },
	    { EP0, G, 10, 15 }, { EP1, B, 3, 0 }, { EP0, B, 10, 15 },
	},
	// Mode 16: Illegal
	{},
	// Mode 17: Illegal
	{},
	// Mode 18
	{ { Mode, None, 4, 0, { 18, true, 2, 8, { 6, 5, 5 } } },
	  { EP0, R, 7, 0 }, { EP3, G, 4, 4 }, { EP2, B, 4, 4 },
	  { EP0, G, 7, 0 }, { EP3, B, 2, 2 }, { EP2, G, 4, 4 },
	  { EP0, B, 7, 0 }, { EP3, B, 3, 3 }, { EP3, B, 4, 4 },
      { EP1, R, 5, 0 }, { EP2, G, 3, 0 }, { EP1, G, 4, 0 },
      { EP3, B, 0, 0 }, { EP3, G, 3, 0 }, { EP1, B, 4, 0 },
      { EP3, B, 1, 1 }, { EP2, B, 3, 0 }, { EP2, R, 5, 0 },
      { EP3, R, 5, 0 },
	  { Partition, None, 4, 0 } },
	// Mode 19: Reserved
	{},
	// Mode 20: Illegal
	{},
	// Mode 21: Illegal
	{},
	// Mode 22:
	{ { Mode, None, 4, 0, { 22, true, 2, 8, { 5, 6, 5 } } },
	  { EP0, R, 7, 0 }, { EP3, B, 0, 0 }, { EP2, B, 4, 4 },
	  { EP0, G, 7, 0 }, { EP2, G, 5, 5 }, { EP2, G, 4, 4 },
      { EP0, B, 7, 0 }, { EP3, G, 5, 5 }, { EP3, B, 4, 4 },
      { EP1, R, 4, 0 }, { EP3, G, 4, 4 }, { EP2, G, 3, 0 },
      { EP1, G, 5, 0 }, { EP3, G, 3, 0 }, { EP1, B, 4, 0 },
      { EP3, B, 1, 1 }, { EP2, B, 3, 0 }, { EP2, R, 4, 0 },
      { EP3, B, 2, 2 }, { EP3, R, 4, 0 }, { EP3, B, 3, 3 },
	  { Partition, None, 4, 0 } },
	// Mode 23: Reserved
	{},
	// Mode 24: Illegal
	{},
	// Mode 25: Illegal
	{},
	// Mode 26
	{ { Mode, None, 4, 0, { 26, true, 2, 8, { 5, 5, 6 } } },
	  { EP0, R, 7, 0 }, { EP3, B, 1, 1 }, { EP2, B, 4, 4 },
	  { EP0, G, 7, 0 }, { EP2, B, 5, 5 }, { EP2, G, 4, 4 },
	  { EP0, B, 7, 0 }, { EP3, B, 5, 5 }, { EP3, B, 4, 4 },
      { EP1, R, 4, 0 }, { EP3, G, 4, 4 }, { EP2, G, 3, 0 },
      { EP1, G, 4, 0 }, { EP3, B, 0, 0 }, { EP3, G, 3, 0 },
      { EP1, B, 5, 0 }, { EP2, B, 3, 0 }, { EP2, R, 4, 0 },
      { EP3, B, 2, 2 }, { EP3, R, 4, 0 }, { EP3, B, 3, 3 },
	  { Partition, None, 4, 0 } },
	// Mode 27: Reserved
	{},
	// Mode 28: Illegal
	{},
	// Mode 29: Illegal
	{},
	// Mode 30
	{ { Mode, None, 4, 0, { 30, false, 2, 6, { 0, 0, 0 } } },
	  { EP0, R, 5, 0 }, { EP3, G, 4, 4 }, { EP3, B, 0, 0 },
      { EP3, B, 1, 1 }, { EP2, B, 4, 4 }, { EP0, G, 5, 0 },
      { EP2, G, 5, 5 }, { EP2, B, 5, 5 }, { EP3, B, 2, 2 },
      { EP2, G, 4, 4 }, { EP0, B, 5, 0 }, { EP3, G, 5, 5 },
      { EP3, B, 3, 3 }, { EP3, B, 5, 5 }, { EP3, B, 4, 4 },
      { EP1, R, 5, 0 }, { EP2, G, 3, 0 }, { EP1, G, 5, 0 },
      { EP3, G, 3, 0 }, { EP1, B, 5, 0 }, { EP2, B, 3, 0 },
      { EP2, R, 5, 0 }, { EP3, R, 5, 0 },
	  { Partition, None, 4, 0 } },
	// Mode 31: Reserved
	{},
	// clang-format on
};

struct Block
{
	uint64_t low64;
	uint64_t high64;

	void decode(uint8_t *dst, int dstX, int dstY, int dstWidth, int dstHeight, size_t dstPitch, size_t dstBpp, bool isSigned) const
	{
		uint8_t mode = 0;
		Data data(low64, high64);
		ASSERT(dstBpp == sizeof(Color));

		if((data.low64 & 0x2) == 0)
		{
			mode = data.consumeBits(1, 0);
		}
		else
		{
			mode = data.consumeBits(4, 0);
		}

		// Illegal or reserved mode
		if(blockDescs[mode].size() == 0)
		{
			for(int y = 0; y < 4 && y + dstY < dstHeight; y++)
			{
				for(int x = 0; x < 4 && x + dstX < dstWidth; x++)
				{
					auto out = reinterpret_cast<Color *>(dst + sizeof(Color) * x + dstPitch * y);
					out->rgba = { 0, 0, 0 };
				}
			}
			return;
		}

		RGBf e[4];
		e[0].isSigned = e[1].isSigned = e[2].isSigned = e[3].isSigned = isSigned;

		int partition = 0;
		ModeDesc modeDesc;
		// For assertion checks
		modeDesc.number = -1;
		for(auto desc : blockDescs[mode])
		{
			switch(desc.type)
			{
				case Mode:
					modeDesc = desc.modeDesc;
					ASSERT(modeDesc.number == mode);

					e[0].size[0] = e[0].size[1] = e[0].size[2] = modeDesc.endpointBits;
					for(int i = 0; i < RGBfChannels; i++)
					{
						if(modeDesc.hasDelta)
						{
							e[1].size[i] = e[2].size[i] = e[3].size[i] = modeDesc.deltaBits.channel[i];
						}
						else
						{
							e[1].size[i] = e[2].size[i] = e[3].size[i] = modeDesc.endpointBits;
						}
					}
					break;
				case Partition:
					partition |= data.consumeBits(desc.MSB, desc.LSB);
					break;
				case EP0:
				case EP1:
				case EP2:
				case EP3:
					e[desc.type].channel[desc.channel] |= data.consumeBits(desc.MSB, desc.LSB);
					break;
				default:
					ASSERT_MSG(false, "Unexpected enum value: %d", (int)desc.type);
					return;
			}
		}

		ASSERT_MSG(modeDesc.number != -1, "Failed to decode mode %d", mode);

		// Sign extension
		if(isSigned)
		{
			for(int ep = 0; ep < modeDesc.numEndpoints; ep++)
			{
				e[ep].extendSign();
			}
		}
		else if(modeDesc.hasDelta)
		{
			// Don't sign-extend the base endpoint in an unsigned format.
			for(int ep = 1; ep < modeDesc.numEndpoints; ep++)
			{
				e[ep].extendSign();
			}
		}

		// Turn the deltas into endpoints
		if(modeDesc.hasDelta)
		{
			for(int ep = 1; ep < modeDesc.numEndpoints; ep++)
			{
				e[ep].resolveDelta(e[0]);
			}
		}

		for(int ep = 0; ep < modeDesc.numEndpoints; ep++)
		{
			e[ep].unquantize();
		}

		// Get the indices, calculate final colors, and output
		for(int y = 0; y < 4; y++)
		{
			for(int x = 0; x < 4; x++)
			{
				int pixelNum = x + y * 4;
				IndexInfo idx;
				bool isAnchor = false;
				int firstEndpoint = 0;
				// Bc6H can have either 1 or 2 petitions depending on the mode.
				// The number of petitions affects the number of indices with implicit
				// leading 0 bits and the number of bits per index.
				if(modeDesc.partitionCount == 1)
				{
					idx.numBits = 4;
					// There's an implicit leading 0 bit for the first idx
					isAnchor = (pixelNum == 0);
				}
				else
				{
					idx.numBits = 3;
					// There are 2 indices with implicit leading 0-bits.
					isAnchor = ((pixelNum == 0) || (pixelNum == AnchorTable2[partition]));
					firstEndpoint = PartitionTable2[partition][pixelNum] * 2;
				}

				idx.value = data.consumeBits(idx.numBits - isAnchor - 1, 0);

				// Don't exit the loop early, we need to consume these index bits regardless if
				// we actually output them or not.
				if((y + dstY >= dstHeight) || (x + dstX >= dstWidth))
				{
					continue;
				}

				Color color = interpolate(e[firstEndpoint], e[firstEndpoint + 1], idx, isSigned);
				auto out = reinterpret_cast<Color *>(dst + dstBpp * x + dstPitch * y);
				*out = color;
			}
		}
	}
};

}  // namespace BC6H

namespace BC7 {
// https://www.khronos.org/registry/OpenGL/extensions/ARB/ARB_texture_compression_bptc.txt
// https://docs.microsoft.com/en-us/windows/win32/direct3d11/bc7-format

struct Bitfield
{
	int offset;
	int count;
	constexpr Bitfield Then(const int bits) { return { offset + count, bits }; }
	constexpr bool operator==(const Bitfield &rhs)
	{
		return offset == rhs.offset && count == rhs.count;
	}
};

struct Mode
{
	const int IDX;  // Mode index
	const int NS;   // Number of subsets in each partition
	const int PB;   // Partition bits
	const int RB;   // Rotation bits
	const int ISB;  // Index selection bits
	const int CB;   // Color bits
	const int AB;   // Alpha bits
	const int EPB;  // Endpoint P-bits
	const int SPB;  // Shared P-bits
	const int IB;   // Primary index bits per element
	const int IBC;  // Primary index bits total
	const int IB2;  // Secondary index bits per element

	constexpr int NumColors() const { return NS * 2; }
	constexpr Bitfield Partition() const { return { IDX + 1, PB }; }
	constexpr Bitfield Rotation() const { return Partition().Then(RB); }
	constexpr Bitfield IndexSelection() const { return Rotation().Then(ISB); }
	constexpr Bitfield Red(int idx) const
	{
		return IndexSelection().Then(CB * idx).Then(CB);
	}
	constexpr Bitfield Green(int idx) const
	{
		return Red(NumColors() - 1).Then(CB * idx).Then(CB);
	}
	constexpr Bitfield Blue(int idx) const
	{
		return Green(NumColors() - 1).Then(CB * idx).Then(CB);
	}
	constexpr Bitfield Alpha(int idx) const
	{
		return Blue(NumColors() - 1).Then(AB * idx).Then(AB);
	}
	constexpr Bitfield EndpointPBit(int idx) const
	{
		return Alpha(NumColors() - 1).Then(EPB * idx).Then(EPB);
	}
	constexpr Bitfield SharedPBit0() const
	{
		return EndpointPBit(NumColors() - 1).Then(SPB);
	}
	constexpr Bitfield SharedPBit1() const
	{
		return SharedPBit0().Then(SPB);
	}
	constexpr Bitfield PrimaryIndex(int offset, int count) const
	{
		return SharedPBit1().Then(offset).Then(count);
	}
	constexpr Bitfield SecondaryIndex(int offset, int count) const
	{
		return SharedPBit1().Then(IBC + offset).Then(count);
	}
};

static constexpr Mode Modes[] = {
	//     IDX  NS   PB   RB   ISB  CB   AB   EPB  SPB  IB   IBC, IB2
	/**/ { 0x0, 0x3, 0x4, 0x0, 0x0, 0x4, 0x0, 0x1, 0x0, 0x3, 0x2d, 0x0 },
	/**/ { 0x1, 0x2, 0x6, 0x0, 0x0, 0x6, 0x0, 0x0, 0x1, 0x3, 0x2e, 0x0 },
	/**/ { 0x2, 0x3, 0x6, 0x0, 0x0, 0x5, 0x0, 0x0, 0x0, 0x2, 0x1d, 0x0 },
	/**/ { 0x3, 0x2, 0x6, 0x0, 0x0, 0x7, 0x0, 0x1, 0x0, 0x2, 0x1e, 0x0 },
	/**/ { 0x4, 0x1, 0x0, 0x2, 0x1, 0x5, 0x6, 0x0, 0x0, 0x2, 0x1f, 0x3 },
	/**/ { 0x5, 0x1, 0x0, 0x2, 0x0, 0x7, 0x8, 0x0, 0x0, 0x2, 0x1f, 0x2 },
	/**/ { 0x6, 0x1, 0x0, 0x0, 0x0, 0x7, 0x7, 0x1, 0x0, 0x4, 0x3f, 0x0 },
	/**/ { 0x7, 0x2, 0x6, 0x0, 0x0, 0x5, 0x5, 0x1, 0x0, 0x2, 0x1e, 0x0 },
	/**/ { -1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x00, 0x0 },
};

static_assert(Modes[0].NumColors() == 6, "BC7 static assertion failed");
static_assert(Modes[0].Partition() == Bitfield{ 1, 4 }, "BC7 static assertion failed");
static_assert(Modes[0].Red(0) == Bitfield{ 5, 4 }, "BC7 static assertion failed");
static_assert(Modes[0].Red(5) == Bitfield{ 25, 4 }, "BC7 static assertion failed");
static_assert(Modes[0].Green(0) == Bitfield{ 29, 4 }, "BC7 static assertion failed");
static_assert(Modes[0].Green(5) == Bitfield{ 49, 4 }, "BC7 static assertion failed");
static_assert(Modes[0].Blue(0) == Bitfield{ 53, 4 }, "BC7 static assertion failed");
static_assert(Modes[0].Blue(5) == Bitfield{ 73, 4 }, "BC7 static assertion failed");
static_assert(Modes[0].EndpointPBit(0) == Bitfield{ 77, 1 }, "BC7 static assertion failed");
static_assert(Modes[0].EndpointPBit(5) == Bitfield{ 82, 1 }, "BC7 static assertion failed");
static_assert(Modes[0].PrimaryIndex(0, 2) == Bitfield{ 83, 2 }, "BC7 static asassertionsert failed");
static_assert(Modes[0].PrimaryIndex(43, 1) == Bitfield{ 126, 1 }, "BC7 static assertion failed");

static constexpr int MaxPartitions = 64;
static constexpr int MaxSubsets = 3;

static constexpr uint8_t PartitionTable2[MaxPartitions][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 constexpr uint8_t PartitionTable3[MaxPartitions][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 constexpr uint8_t AnchorTable2[MaxPartitions] = {
	// clang-format off
	0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf,
	0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf,
	0xf, 0x2, 0x8, 0x2, 0x2, 0x8, 0x8, 0xf,
	0x2, 0x8, 0x2, 0x2, 0x8, 0x8, 0x2, 0x2,
	0xf, 0xf, 0x6, 0x8, 0x2, 0x8, 0xf, 0xf,
	0x2, 0x8, 0x2, 0x2, 0x2, 0xf, 0xf, 0x6,
	0x6, 0x2, 0x6, 0x8, 0xf, 0xf, 0x2, 0x2,
	0xf, 0xf, 0xf, 0xf, 0xf, 0x2, 0x2, 0xf,
	// clang-format on
};

static constexpr uint8_t AnchorTable3a[MaxPartitions] = {
	// clang-format off
	0x3, 0x3, 0xf, 0xf, 0x8, 0x3, 0xf, 0xf,
	0x8, 0x8, 0x6, 0x6, 0x6, 0x5, 0x3, 0x3,
	0x3, 0x3, 0x8, 0xf, 0x3, 0x3, 0x6, 0xa,
	0x5, 0x8, 0x8, 0x6, 0x8, 0x5, 0xf, 0xf,
	0x8, 0xf, 0x3, 0x5, 0x6, 0xa, 0x8, 0xf,
	0xf, 0x3, 0xf, 0x5, 0xf, 0xf, 0xf, 0xf,
	0x3, 0xf, 0x5, 0x5, 0x5, 0x8, 0x5, 0xa,
	0x5, 0xa, 0x8, 0xd, 0xf, 0xc, 0x3, 0x3,
	// clang-format on
};

static constexpr uint8_t AnchorTable3b[MaxPartitions] = {
	// clang-format off
	0xf, 0x8, 0x8, 0x3, 0xf, 0xf, 0x3, 0x8,
	0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf, 0x8,
	0xf, 0x8, 0xf, 0x3, 0xf, 0x8, 0xf, 0x8,
	0x3, 0xf, 0x6, 0xa, 0xf, 0xf, 0xa, 0x8,
	0xf, 0x3, 0xf, 0xa, 0xa, 0x8, 0x9, 0xa,
	0x6, 0xf, 0x8, 0xf, 0x3, 0x6, 0x6, 0x8,
	0xf, 0x3, 0xf, 0xf, 0xf, 0xf, 0xf, 0xf,
	0xf, 0xf, 0xf, 0xf, 0x3, 0xf, 0xf, 0x8,
	// clang-format on
};

struct Color
{
	struct RGB
	{
		RGB() = default;
		RGB(uint8_t r, uint8_t g, uint8_t b)
		    : b(b)
		    , g(g)
		    , r(r)
		{}
		RGB(int r, int g, int b)
		    : b(static_cast<uint8_t>(b))
		    , g(static_cast<uint8_t>(g))
		    , r(static_cast<uint8_t>(r))
		{}

		RGB operator<<(int shift) const { return { r << shift, g << shift, b << shift }; }
		RGB operator>>(int shift) const { return { r >> shift, g >> shift, b >> shift }; }
		RGB operator|(int bits) const { return { r | bits, g | bits, b | bits }; }
		RGB operator|(const RGB &rhs) const { return { r | rhs.r, g | rhs.g, b | rhs.b }; }
		RGB operator+(const RGB &rhs) const { return { r + rhs.r, g + rhs.g, b + rhs.b }; }

		uint8_t b;
		uint8_t g;
		uint8_t r;
	};

	RGB rgb;
	uint8_t a;
};

static_assert(sizeof(Color) == 4, "Color size must be 4 bytes");

struct Block
{
	constexpr uint64_t Get(const Bitfield &bf) const
	{
		uint64_t mask = (1ULL << bf.count) - 1;
		if(bf.offset + bf.count <= 64)
		{
			return (low >> bf.offset) & mask;
		}
		if(bf.offset >= 64)
		{
			return (high >> (bf.offset - 64)) & mask;
		}
		return ((low >> bf.offset) | (high << (64 - bf.offset))) & mask;
	}

	const Mode &mode() const
	{
		if((low & 0b00000001) != 0) { return Modes[0]; }
		if((low & 0b00000010) != 0) { return Modes[1]; }
		if((low & 0b00000100) != 0) { return Modes[2]; }
		if((low & 0b00001000) != 0) { return Modes[3]; }
		if((low & 0b00010000) != 0) { return Modes[4]; }
		if((low & 0b00100000) != 0) { return Modes[5]; }
		if((low & 0b01000000) != 0) { return Modes[6]; }
		if((low & 0b10000000) != 0) { return Modes[7]; }
		return Modes[8];  // Invalid mode
	}

	struct IndexInfo
	{
		uint64_t value;
		int numBits;
	};

	uint8_t interpolate(uint8_t e0, uint8_t e1, const IndexInfo &index) const
	{
		static constexpr uint16_t weights2[] = { 0, 21, 43, 64 };
		static constexpr uint16_t weights3[] = { 0, 9, 18, 27, 37, 46, 55, 64 };
		static constexpr uint16_t weights4[] = { 0, 4, 9, 13, 17, 21, 26, 30,
			                                     34, 38, 43, 47, 51, 55, 60, 64 };
		static constexpr uint16_t const *weightsN[] = {
			nullptr, nullptr, weights2, weights3, weights4
		};
		auto weights = weightsN[index.numBits];
		ASSERT_MSG(weights != nullptr, "Unexpected number of index bits: %d", (int)index.numBits);
		return (uint8_t)(((64 - weights[index.value]) * uint16_t(e0) + weights[index.value] * uint16_t(e1) + 32) >> 6);
	}

	void decode(uint8_t *dst, int dstX, int dstY, int dstWidth, int dstHeight, size_t dstPitch) const
	{
		auto const &mode = this->mode();

		if(mode.IDX < 0)  // Invalid mode:
		{
			for(int y = 0; y < 4 && y + dstY < dstHeight; y++)
			{
				for(int x = 0; x < 4 && x + dstX < dstWidth; x++)
				{
					auto out = reinterpret_cast<Color *>(dst + sizeof(Color) * x + dstPitch * y);
					out->rgb = { 0, 0, 0 };
					out->a = 0;
				}
			}
			return;
		}

		using Endpoint = std::array<Color, 2>;
		std::array<Endpoint, MaxSubsets> subsets;

		for(int i = 0; i < mode.NS; i++)
		{
			auto &subset = subsets[i];
			subset[0].rgb.r = Get(mode.Red(i * 2 + 0));
			subset[0].rgb.g = Get(mode.Green(i * 2 + 0));
			subset[0].rgb.b = Get(mode.Blue(i * 2 + 0));
			subset[0].a = (mode.AB > 0) ? Get(mode.Alpha(i * 2 + 0)) : 255;

			subset[1].rgb.r = Get(mode.Red(i * 2 + 1));
			subset[1].rgb.g = Get(mode.Green(i * 2 + 1));
			subset[1].rgb.b = Get(mode.Blue(i * 2 + 1));
			subset[1].a = (mode.AB > 0) ? Get(mode.Alpha(i * 2 + 1)) : 255;
		}

		if(mode.SPB > 0)
		{
			auto pbit0 = Get(mode.SharedPBit0());
			auto pbit1 = Get(mode.SharedPBit1());
			subsets[0][0].rgb = (subsets[0][0].rgb << 1) | pbit0;
			subsets[0][1].rgb = (subsets[0][1].rgb << 1) | pbit0;
			subsets[1][0].rgb = (subsets[1][0].rgb << 1) | pbit1;
			subsets[1][1].rgb = (subsets[1][1].rgb << 1) | pbit1;
		}

		if(mode.EPB > 0)
		{
			for(int i = 0; i < mode.NS; i++)
			{
				auto &subset = subsets[i];
				auto pbit0 = Get(mode.EndpointPBit(i * 2 + 0));
				auto pbit1 = Get(mode.EndpointPBit(i * 2 + 1));
				subset[0].rgb = (subset[0].rgb << 1) | pbit0;
				subset[1].rgb = (subset[1].rgb << 1) | pbit1;
				if(mode.AB > 0)
				{
					subset[0].a = (subset[0].a << 1) | pbit0;
					subset[1].a = (subset[1].a << 1) | pbit1;
				}
			}
		}

		auto const colorBits = mode.CB + mode.SPB + mode.EPB;
		auto const alphaBits = mode.AB + mode.SPB + mode.EPB;

		for(int i = 0; i < mode.NS; i++)
		{
			auto &subset = subsets[i];
			subset[0].rgb = subset[0].rgb << (8 - colorBits);
			subset[1].rgb = subset[1].rgb << (8 - colorBits);
			subset[0].rgb = subset[0].rgb | (subset[0].rgb >> colorBits);
			subset[1].rgb = subset[1].rgb | (subset[1].rgb >> colorBits);

			if(mode.AB > 0)
			{
				subset[0].a = subset[0].a << (8 - alphaBits);
				subset[1].a = subset[1].a << (8 - alphaBits);
				subset[0].a = subset[0].a | (subset[0].a >> alphaBits);
				subset[1].a = subset[1].a | (subset[1].a >> alphaBits);
			}
		}

		int colorIndexBitOffset = 0;
		int alphaIndexBitOffset = 0;
		for(int y = 0; y < 4; y++)
		{
			for(int x = 0; x < 4; x++)
			{
				auto texelIdx = y * 4 + x;
				auto partitionIdx = Get(mode.Partition());
				ASSERT(partitionIdx < MaxPartitions);
				auto subsetIdx = subsetIndex(mode, partitionIdx, texelIdx);
				ASSERT(subsetIdx < MaxSubsets);
				auto const &subset = subsets[subsetIdx];

				auto anchorIdx = anchorIndex(mode, partitionIdx, subsetIdx);
				auto isAnchor = anchorIdx == texelIdx;
				auto colorIdx = colorIndex(mode, isAnchor, colorIndexBitOffset);
				auto alphaIdx = alphaIndex(mode, isAnchor, alphaIndexBitOffset);

				if(y + dstY >= dstHeight || x + dstX >= dstWidth)
				{
					// Don't be tempted to skip early at the loops:
					// The calls to colorIndex() and alphaIndex() adjust bit
					// offsets that need to be carefully tracked.
					continue;
				}

				Color output;
				output.rgb.r = interpolate(subset[0].rgb.r, subset[1].rgb.r, colorIdx);
				output.rgb.g = interpolate(subset[0].rgb.g, subset[1].rgb.g, colorIdx);
				output.rgb.b = interpolate(subset[0].rgb.b, subset[1].rgb.b, colorIdx);
				output.a = interpolate(subset[0].a, subset[1].a, alphaIdx);

				switch(Get(mode.Rotation()))
				{
					default:
						break;
					case 1:
						std::swap(output.a, output.rgb.r);
						break;
					case 2:
						std::swap(output.a, output.rgb.g);
						break;
					case 3:
						std::swap(output.a, output.rgb.b);
						break;
				}

				auto out = reinterpret_cast<Color *>(dst + sizeof(Color) * x + dstPitch * y);
				*out = output;
			}
		}
	}

	int subsetIndex(const Mode &mode, int partitionIdx, int texelIndex) const
	{
		switch(mode.NS)
		{
			default:
				return 0;
			case 2:
				return PartitionTable2[partitionIdx][texelIndex];
			case 3:
				return PartitionTable3[partitionIdx][texelIndex];
		}
	}

	int anchorIndex(const Mode &mode, int partitionIdx, int subsetIdx) const
	{
		// ARB_texture_compression_bptc states:
		// "In partition zero, the anchor index is always index zero.
		// In other partitions, the anchor index is specified by tables
		// Table.A2 and Table.A3.""
		// Note: This is really confusing - I believe they meant subset instead
		// of partition here.
		switch(subsetIdx)
		{
			default:
				return 0;
			case 1:
				return mode.NS == 2 ? AnchorTable2[partitionIdx] : AnchorTable3a[partitionIdx];
			case 2:
				return AnchorTable3b[partitionIdx];
		}
	}

	IndexInfo colorIndex(const Mode &mode, bool isAnchor,
	                     int &indexBitOffset) const
	{
		// ARB_texture_compression_bptc states:
		// "The index value for interpolating color comes from the secondary
		// index for the texel if the format has an index selection bit and its
		// value is one and from the primary index otherwise.""
		auto idx = Get(mode.IndexSelection());
		ASSERT(idx <= 1);
		bool secondary = idx == 1;
		auto numBits = secondary ? mode.IB2 : mode.IB;
		auto numReadBits = numBits - (isAnchor ? 1 : 0);
		auto index =
		    Get(secondary ? mode.SecondaryIndex(indexBitOffset, numReadBits)
		                  : mode.PrimaryIndex(indexBitOffset, numReadBits));
		indexBitOffset += numReadBits;
		return { index, numBits };
	}

	IndexInfo alphaIndex(const Mode &mode, bool isAnchor,
	                     int &indexBitOffset) const
	{
		// ARB_texture_compression_bptc states:
		// "The alpha index comes from the secondary index if the block has a
		// secondary index and the block either doesn't have an index selection
		// bit or that bit is zero and the primary index otherwise."
		auto idx = Get(mode.IndexSelection());
		ASSERT(idx <= 1);
		bool secondary = (mode.IB2 != 0) && (idx == 0);
		auto numBits = secondary ? mode.IB2 : mode.IB;
		auto numReadBits = numBits - (isAnchor ? 1 : 0);
		auto index =
		    Get(secondary ? mode.SecondaryIndex(indexBitOffset, numReadBits)
		                  : mode.PrimaryIndex(indexBitOffset, numReadBits));
		indexBitOffset += numReadBits;
		return { index, numBits };
	}

	// Assumes little-endian
	uint64_t low;
	uint64_t high;
};

}  // namespace BC7
}  // anonymous namespace

// Decodes 1 to 4 channel images to 8 bit output
bool BC_Decoder::Decode(const uint8_t *src, uint8_t *dst, int w, int h, int dstPitch, int dstBpp, int n, bool isNoAlphaU)
{
	static_assert(sizeof(BC_color) == 8, "BC_color must be 8 bytes");
	static_assert(sizeof(BC_channel) == 8, "BC_channel must be 8 bytes");
	static_assert(sizeof(BC_alpha) == 8, "BC_alpha must be 8 bytes");

	const int dx = BlockWidth * dstBpp;
	const int dy = BlockHeight * dstPitch;
	const bool isAlpha = (n == 1) && !isNoAlphaU;
	const bool isSigned = ((n == 4) || (n == 5) || (n == 6)) && !isNoAlphaU;

	switch(n)
	{
		case 1:  // BC1
		{
			const BC_color *color = reinterpret_cast<const BC_color *>(src);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				uint8_t *dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, ++color, dstRow += dx)
				{
					color->decode(dstRow, x, y, w, h, dstPitch, dstBpp, isAlpha, false);
				}
			}
		}
		break;
		case 2:  // BC2
		{
			const BC_alpha *alpha = reinterpret_cast<const BC_alpha *>(src);
			const BC_color *color = reinterpret_cast<const BC_color *>(src + 8);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				uint8_t *dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, alpha += 2, color += 2, dstRow += dx)
				{
					color->decode(dstRow, x, y, w, h, dstPitch, dstBpp, isAlpha, true);
					alpha->decode(dstRow, x, y, w, h, dstPitch, dstBpp);
				}
			}
		}
		break;
		case 3:  // BC3
		{
			const BC_channel *alpha = reinterpret_cast<const BC_channel *>(src);
			const BC_color *color = reinterpret_cast<const BC_color *>(src + 8);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				uint8_t *dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, alpha += 2, color += 2, dstRow += dx)
				{
					color->decode(dstRow, x, y, w, h, dstPitch, dstBpp, isAlpha, true);
					alpha->decode(dstRow, x, y, w, h, dstPitch, dstBpp, 3, isSigned);
				}
			}
		}
		break;
		case 4:  // BC4
		{
			const BC_channel *red = reinterpret_cast<const BC_channel *>(src);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				uint8_t *dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, ++red, dstRow += dx)
				{
					red->decode(dstRow, x, y, w, h, dstPitch, dstBpp, 0, isSigned);
				}
			}
		}
		break;
		case 5:  // BC5
		{
			const BC_channel *red = reinterpret_cast<const BC_channel *>(src);
			const BC_channel *green = reinterpret_cast<const BC_channel *>(src + 8);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				uint8_t *dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, red += 2, green += 2, dstRow += dx)
				{
					red->decode(dstRow, x, y, w, h, dstPitch, dstBpp, 0, isSigned);
					green->decode(dstRow, x, y, w, h, dstPitch, dstBpp, 1, isSigned);
				}
			}
		}
		break;
		case 6:  // BC6H
		{
			const BC6H::Block *block = reinterpret_cast<const BC6H::Block *>(src);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				uint8_t *dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, ++block, dstRow += dx)
				{
					block->decode(dstRow, x, y, w, h, dstPitch, dstBpp, isSigned);
				}
			}
		}
		break;
		case 7:  // BC7
		{
			const BC7::Block *block = reinterpret_cast<const BC7::Block *>(src);
			for(int y = 0; y < h; y += BlockHeight, dst += dy)
			{
				uint8_t *dstRow = dst;
				for(int x = 0; x < w; x += BlockWidth, ++block, dstRow += dx)
				{
					block->decode(dstRow, x, y, w, h, dstPitch);
				}
			}
		}
		break;
		default:
			return false;
	}

	return true;
}