// ----------------------------------------------------------------------------
//  This confidential and proprietary software may be used only as authorised
//  by a licensing agreement from Arm Limited.
//      (C) COPYRIGHT 2011-2019 Arm Limited, ALL RIGHTS RESERVED
//  The entire notice above must be reproduced on all authorised copies and
//  copies may only be made to the extent permitted by a licensing agreement
//  from Arm Limited.
// ----------------------------------------------------------------------------

/**
 * @brief Functions for encoding/decoding Bounded Integer Sequence Encoding.
 */

#include "astc_codec_internals.h"

// unpacked quint triplets <low,middle,high> for each packed-quint value
static const uint8_t quints_of_integer[128][3] = {
	{0, 0, 0},	{1, 0, 0},	{2, 0, 0},	{3, 0, 0},
	{4, 0, 0},	{0, 4, 0},	{4, 4, 0},	{4, 4, 4},
	{0, 1, 0},	{1, 1, 0},	{2, 1, 0},	{3, 1, 0},
	{4, 1, 0},	{1, 4, 0},	{4, 4, 1},	{4, 4, 4},
	{0, 2, 0},	{1, 2, 0},	{2, 2, 0},	{3, 2, 0},
	{4, 2, 0},	{2, 4, 0},	{4, 4, 2},	{4, 4, 4},
	{0, 3, 0},	{1, 3, 0},	{2, 3, 0},	{3, 3, 0},
	{4, 3, 0},	{3, 4, 0},	{4, 4, 3},	{4, 4, 4},
	{0, 0, 1},	{1, 0, 1},	{2, 0, 1},	{3, 0, 1},
	{4, 0, 1},	{0, 4, 1},	{4, 0, 4},	{0, 4, 4},
	{0, 1, 1},	{1, 1, 1},	{2, 1, 1},	{3, 1, 1},
	{4, 1, 1},	{1, 4, 1},	{4, 1, 4},	{1, 4, 4},
	{0, 2, 1},	{1, 2, 1},	{2, 2, 1},	{3, 2, 1},
	{4, 2, 1},	{2, 4, 1},	{4, 2, 4},	{2, 4, 4},
	{0, 3, 1},	{1, 3, 1},	{2, 3, 1},	{3, 3, 1},
	{4, 3, 1},	{3, 4, 1},	{4, 3, 4},	{3, 4, 4},
	{0, 0, 2},	{1, 0, 2},	{2, 0, 2},	{3, 0, 2},
	{4, 0, 2},	{0, 4, 2},	{2, 0, 4},	{3, 0, 4},
	{0, 1, 2},	{1, 1, 2},	{2, 1, 2},	{3, 1, 2},
	{4, 1, 2},	{1, 4, 2},	{2, 1, 4},	{3, 1, 4},
	{0, 2, 2},	{1, 2, 2},	{2, 2, 2},	{3, 2, 2},
	{4, 2, 2},	{2, 4, 2},	{2, 2, 4},	{3, 2, 4},
	{0, 3, 2},	{1, 3, 2},	{2, 3, 2},	{3, 3, 2},
	{4, 3, 2},	{3, 4, 2},	{2, 3, 4},	{3, 3, 4},
	{0, 0, 3},	{1, 0, 3},	{2, 0, 3},	{3, 0, 3},
	{4, 0, 3},	{0, 4, 3},	{0, 0, 4},	{1, 0, 4},
	{0, 1, 3},	{1, 1, 3},	{2, 1, 3},	{3, 1, 3},
	{4, 1, 3},	{1, 4, 3},	{0, 1, 4},	{1, 1, 4},
	{0, 2, 3},	{1, 2, 3},	{2, 2, 3},	{3, 2, 3},
	{4, 2, 3},	{2, 4, 3},	{0, 2, 4},	{1, 2, 4},
	{0, 3, 3},	{1, 3, 3},	{2, 3, 3},	{3, 3, 3},
	{4, 3, 3},	{3, 4, 3},	{0, 3, 4},	{1, 3, 4}
};

// packed quint-value for every unpacked quint-triplet
// indexed by [high][middle][low]
static const uint8_t integer_of_quints[5][5][5] = {
	{
		{0, 1, 2, 3, 4},
		{8, 9, 10, 11, 12},
		{16, 17, 18, 19, 20},
		{24, 25, 26, 27, 28},
		{5, 13, 21, 29, 6}
	},
	{
		{32, 33, 34, 35, 36},
		{40, 41, 42, 43, 44},
		{48, 49, 50, 51, 52},
		{56, 57, 58, 59, 60},
		{37, 45, 53, 61, 14}
	},
	{
		{64, 65, 66, 67, 68},
		{72, 73, 74, 75, 76},
		{80, 81, 82, 83, 84},
		{88, 89, 90, 91, 92},
		{69, 77, 85, 93, 22}
	},
	{
		{96, 97, 98, 99, 100},
		{104, 105, 106, 107, 108},
		{112, 113, 114, 115, 116},
		{120, 121, 122, 123, 124},
		{101, 109, 117, 125, 30}
	},
	{
		{102, 103, 70, 71, 38},
		{110, 111, 78, 79, 46},
		{118, 119, 86, 87, 54},
		{126, 127, 94, 95, 62},
		{39, 47, 55, 63, 31}
	}
};

// unpacked trit quintuplets <low,_,_,_,high> for each packed-quint value
static const uint8_t trits_of_integer[256][5] = {
	{0, 0, 0, 0, 0}, {1, 0, 0, 0, 0}, {2, 0, 0, 0, 0}, {0, 0, 2, 0, 0},
	{0, 1, 0, 0, 0}, {1, 1, 0, 0, 0}, {2, 1, 0, 0, 0}, {1, 0, 2, 0, 0},
	{0, 2, 0, 0, 0}, {1, 2, 0, 0, 0}, {2, 2, 0, 0, 0}, {2, 0, 2, 0, 0},
	{0, 2, 2, 0, 0}, {1, 2, 2, 0, 0}, {2, 2, 2, 0, 0}, {2, 0, 2, 0, 0},
	{0, 0, 1, 0, 0}, {1, 0, 1, 0, 0}, {2, 0, 1, 0, 0}, {0, 1, 2, 0, 0},
	{0, 1, 1, 0, 0}, {1, 1, 1, 0, 0}, {2, 1, 1, 0, 0}, {1, 1, 2, 0, 0},
	{0, 2, 1, 0, 0}, {1, 2, 1, 0, 0}, {2, 2, 1, 0, 0}, {2, 1, 2, 0, 0},
	{0, 0, 0, 2, 2}, {1, 0, 0, 2, 2}, {2, 0, 0, 2, 2}, {0, 0, 2, 2, 2},
	{0, 0, 0, 1, 0}, {1, 0, 0, 1, 0}, {2, 0, 0, 1, 0}, {0, 0, 2, 1, 0},
	{0, 1, 0, 1, 0}, {1, 1, 0, 1, 0}, {2, 1, 0, 1, 0}, {1, 0, 2, 1, 0},
	{0, 2, 0, 1, 0}, {1, 2, 0, 1, 0}, {2, 2, 0, 1, 0}, {2, 0, 2, 1, 0},
	{0, 2, 2, 1, 0}, {1, 2, 2, 1, 0}, {2, 2, 2, 1, 0}, {2, 0, 2, 1, 0},
	{0, 0, 1, 1, 0}, {1, 0, 1, 1, 0}, {2, 0, 1, 1, 0}, {0, 1, 2, 1, 0},
	{0, 1, 1, 1, 0}, {1, 1, 1, 1, 0}, {2, 1, 1, 1, 0}, {1, 1, 2, 1, 0},
	{0, 2, 1, 1, 0}, {1, 2, 1, 1, 0}, {2, 2, 1, 1, 0}, {2, 1, 2, 1, 0},
	{0, 1, 0, 2, 2}, {1, 1, 0, 2, 2}, {2, 1, 0, 2, 2}, {1, 0, 2, 2, 2},
	{0, 0, 0, 2, 0}, {1, 0, 0, 2, 0}, {2, 0, 0, 2, 0}, {0, 0, 2, 2, 0},
	{0, 1, 0, 2, 0}, {1, 1, 0, 2, 0}, {2, 1, 0, 2, 0}, {1, 0, 2, 2, 0},
	{0, 2, 0, 2, 0}, {1, 2, 0, 2, 0}, {2, 2, 0, 2, 0}, {2, 0, 2, 2, 0},
	{0, 2, 2, 2, 0}, {1, 2, 2, 2, 0}, {2, 2, 2, 2, 0}, {2, 0, 2, 2, 0},
	{0, 0, 1, 2, 0}, {1, 0, 1, 2, 0}, {2, 0, 1, 2, 0}, {0, 1, 2, 2, 0},
	{0, 1, 1, 2, 0}, {1, 1, 1, 2, 0}, {2, 1, 1, 2, 0}, {1, 1, 2, 2, 0},
	{0, 2, 1, 2, 0}, {1, 2, 1, 2, 0}, {2, 2, 1, 2, 0}, {2, 1, 2, 2, 0},
	{0, 2, 0, 2, 2}, {1, 2, 0, 2, 2}, {2, 2, 0, 2, 2}, {2, 0, 2, 2, 2},
	{0, 0, 0, 0, 2}, {1, 0, 0, 0, 2}, {2, 0, 0, 0, 2}, {0, 0, 2, 0, 2},
	{0, 1, 0, 0, 2}, {1, 1, 0, 0, 2}, {2, 1, 0, 0, 2}, {1, 0, 2, 0, 2},
	{0, 2, 0, 0, 2}, {1, 2, 0, 0, 2}, {2, 2, 0, 0, 2}, {2, 0, 2, 0, 2},
	{0, 2, 2, 0, 2}, {1, 2, 2, 0, 2}, {2, 2, 2, 0, 2}, {2, 0, 2, 0, 2},
	{0, 0, 1, 0, 2}, {1, 0, 1, 0, 2}, {2, 0, 1, 0, 2}, {0, 1, 2, 0, 2},
	{0, 1, 1, 0, 2}, {1, 1, 1, 0, 2}, {2, 1, 1, 0, 2}, {1, 1, 2, 0, 2},
	{0, 2, 1, 0, 2}, {1, 2, 1, 0, 2}, {2, 2, 1, 0, 2}, {2, 1, 2, 0, 2},
	{0, 2, 2, 2, 2}, {1, 2, 2, 2, 2}, {2, 2, 2, 2, 2}, {2, 0, 2, 2, 2},
	{0, 0, 0, 0, 1}, {1, 0, 0, 0, 1}, {2, 0, 0, 0, 1}, {0, 0, 2, 0, 1},
	{0, 1, 0, 0, 1}, {1, 1, 0, 0, 1}, {2, 1, 0, 0, 1}, {1, 0, 2, 0, 1},
	{0, 2, 0, 0, 1}, {1, 2, 0, 0, 1}, {2, 2, 0, 0, 1}, {2, 0, 2, 0, 1},
	{0, 2, 2, 0, 1}, {1, 2, 2, 0, 1}, {2, 2, 2, 0, 1}, {2, 0, 2, 0, 1},
	{0, 0, 1, 0, 1}, {1, 0, 1, 0, 1}, {2, 0, 1, 0, 1}, {0, 1, 2, 0, 1},
	{0, 1, 1, 0, 1}, {1, 1, 1, 0, 1}, {2, 1, 1, 0, 1}, {1, 1, 2, 0, 1},
	{0, 2, 1, 0, 1}, {1, 2, 1, 0, 1}, {2, 2, 1, 0, 1}, {2, 1, 2, 0, 1},
	{0, 0, 1, 2, 2}, {1, 0, 1, 2, 2}, {2, 0, 1, 2, 2}, {0, 1, 2, 2, 2},
	{0, 0, 0, 1, 1}, {1, 0, 0, 1, 1}, {2, 0, 0, 1, 1}, {0, 0, 2, 1, 1},
	{0, 1, 0, 1, 1}, {1, 1, 0, 1, 1}, {2, 1, 0, 1, 1}, {1, 0, 2, 1, 1},
	{0, 2, 0, 1, 1}, {1, 2, 0, 1, 1}, {2, 2, 0, 1, 1}, {2, 0, 2, 1, 1},
	{0, 2, 2, 1, 1}, {1, 2, 2, 1, 1}, {2, 2, 2, 1, 1}, {2, 0, 2, 1, 1},
	{0, 0, 1, 1, 1}, {1, 0, 1, 1, 1}, {2, 0, 1, 1, 1}, {0, 1, 2, 1, 1},
	{0, 1, 1, 1, 1}, {1, 1, 1, 1, 1}, {2, 1, 1, 1, 1}, {1, 1, 2, 1, 1},
	{0, 2, 1, 1, 1}, {1, 2, 1, 1, 1}, {2, 2, 1, 1, 1}, {2, 1, 2, 1, 1},
	{0, 1, 1, 2, 2}, {1, 1, 1, 2, 2}, {2, 1, 1, 2, 2}, {1, 1, 2, 2, 2},
	{0, 0, 0, 2, 1}, {1, 0, 0, 2, 1}, {2, 0, 0, 2, 1}, {0, 0, 2, 2, 1},
	{0, 1, 0, 2, 1}, {1, 1, 0, 2, 1}, {2, 1, 0, 2, 1}, {1, 0, 2, 2, 1},
	{0, 2, 0, 2, 1}, {1, 2, 0, 2, 1}, {2, 2, 0, 2, 1}, {2, 0, 2, 2, 1},
	{0, 2, 2, 2, 1}, {1, 2, 2, 2, 1}, {2, 2, 2, 2, 1}, {2, 0, 2, 2, 1},
	{0, 0, 1, 2, 1}, {1, 0, 1, 2, 1}, {2, 0, 1, 2, 1}, {0, 1, 2, 2, 1},
	{0, 1, 1, 2, 1}, {1, 1, 1, 2, 1}, {2, 1, 1, 2, 1}, {1, 1, 2, 2, 1},
	{0, 2, 1, 2, 1}, {1, 2, 1, 2, 1}, {2, 2, 1, 2, 1}, {2, 1, 2, 2, 1},
	{0, 2, 1, 2, 2}, {1, 2, 1, 2, 2}, {2, 2, 1, 2, 2}, {2, 1, 2, 2, 2},
	{0, 0, 0, 1, 2}, {1, 0, 0, 1, 2}, {2, 0, 0, 1, 2}, {0, 0, 2, 1, 2},
	{0, 1, 0, 1, 2}, {1, 1, 0, 1, 2}, {2, 1, 0, 1, 2}, {1, 0, 2, 1, 2},
	{0, 2, 0, 1, 2}, {1, 2, 0, 1, 2}, {2, 2, 0, 1, 2}, {2, 0, 2, 1, 2},
	{0, 2, 2, 1, 2}, {1, 2, 2, 1, 2}, {2, 2, 2, 1, 2}, {2, 0, 2, 1, 2},
	{0, 0, 1, 1, 2}, {1, 0, 1, 1, 2}, {2, 0, 1, 1, 2}, {0, 1, 2, 1, 2},
	{0, 1, 1, 1, 2}, {1, 1, 1, 1, 2}, {2, 1, 1, 1, 2}, {1, 1, 2, 1, 2},
	{0, 2, 1, 1, 2}, {1, 2, 1, 1, 2}, {2, 2, 1, 1, 2}, {2, 1, 2, 1, 2},
	{0, 2, 2, 2, 2}, {1, 2, 2, 2, 2}, {2, 2, 2, 2, 2}, {2, 1, 2, 2, 2}
};

// packed trit-value for every unpacked trit-quintuplet
// indexed by [high][][][][low]
static const uint8_t integer_of_trits[3][3][3][3][3] = {
	{
		{
			{
				{0, 1, 2},
				{4, 5, 6},
				{8, 9, 10}
			},
			{
				{16, 17, 18},
				{20, 21, 22},
				{24, 25, 26}
			},
			{
				{3, 7, 15},
				{19, 23, 27},
				{12, 13, 14}
			}
		},
		{
			{
				{32, 33, 34},
				{36, 37, 38},
				{40, 41, 42}
			},
			{
				{48, 49, 50},
				{52, 53, 54},
				{56, 57, 58}
			},
			{
				{35, 39, 47},
				{51, 55, 59},
				{44, 45, 46}
			}
		},
		{
			{
				{64, 65, 66},
				{68, 69, 70},
				{72, 73, 74}
			},
			{
				{80, 81, 82},
				{84, 85, 86},
				{88, 89, 90}
			},
			{
				{67, 71, 79},
				{83, 87, 91},
				{76, 77, 78}
			}
		}
	},
	{
		{
			{
				{128, 129, 130},
				{132, 133, 134},
				{136, 137, 138}
			},
			{
				{144, 145, 146},
				{148, 149, 150},
				{152, 153, 154}
			},
			{
				{131, 135, 143},
				{147, 151, 155},
				{140, 141, 142}
			}
		},
		{
			{
				{160, 161, 162},
				{164, 165, 166},
				{168, 169, 170}
			},
			{
				{176, 177, 178},
				{180, 181, 182},
				{184, 185, 186}
			},
			{
				{163, 167, 175},
				{179, 183, 187},
				{172, 173, 174}
			}
		},
		{
			{
				{192, 193, 194},
				{196, 197, 198},
				{200, 201, 202}
			},
			{
				{208, 209, 210},
				{212, 213, 214},
				{216, 217, 218}
			},
			{
				{195, 199, 207},
				{211, 215, 219},
				{204, 205, 206}
			}
		}
	},
	{
		{
			{
				{96, 97, 98},
				{100, 101, 102},
				{104, 105, 106}
			},
			{
				{112, 113, 114},
				{116, 117, 118},
				{120, 121, 122}
			},
			{
				{99, 103, 111},
				{115, 119, 123},
				{108, 109, 110}
			}
		},
		{
			{
				{224, 225, 226},
				{228, 229, 230},
				{232, 233, 234}
			},
			{
				{240, 241, 242},
				{244, 245, 246},
				{248, 249, 250}
			},
			{
				{227, 231, 239},
				{243, 247, 251},
				{236, 237, 238}
			}
		},
		{
			{
				{28, 29, 30},
				{60, 61, 62},
				{92, 93, 94}
			},
			{
				{156, 157, 158},
				{188, 189, 190},
				{220, 221, 222}
			},
			{
				{31, 63, 127},
				{159, 191, 255},
				{252, 253, 254}
			}
		}
	}
};

void find_number_of_bits_trits_quints(int quantization_level, int *bits, int *trits, int *quints)
{
	*bits = 0;
	*trits = 0;
	*quints = 0;
	switch (quantization_level)
	{
	case QUANT_2:
		*bits = 1;
		break;
	case QUANT_3:
		*bits = 0;
		*trits = 1;
		break;
	case QUANT_4:
		*bits = 2;
		break;
	case QUANT_5:
		*bits = 0;
		*quints = 1;
		break;
	case QUANT_6:
		*bits = 1;
		*trits = 1;
		break;
	case QUANT_8:
		*bits = 3;
		break;
	case QUANT_10:
		*bits = 1;
		*quints = 1;
		break;
	case QUANT_12:
		*bits = 2;
		*trits = 1;
		break;
	case QUANT_16:
		*bits = 4;
		break;
	case QUANT_20:
		*bits = 2;
		*quints = 1;
		break;
	case QUANT_24:
		*bits = 3;
		*trits = 1;
		break;
	case QUANT_32:
		*bits = 5;
		break;
	case QUANT_40:
		*bits = 3;
		*quints = 1;
		break;
	case QUANT_48:
		*bits = 4;
		*trits = 1;
		break;
	case QUANT_64:
		*bits = 6;
		break;
	case QUANT_80:
		*bits = 4;
		*quints = 1;
		break;
	case QUANT_96:
		*bits = 5;
		*trits = 1;
		break;
	case QUANT_128:
		*bits = 7;
		break;
	case QUANT_160:
		*bits = 5;
		*quints = 1;
		break;
	case QUANT_192:
		*bits = 6;
		*trits = 1;
		break;
	case QUANT_256:
		*bits = 8;
		break;
	}
}

// routine to write up to 8 bits
static inline void write_bits(int value, int bitcount, int bitoffset, uint8_t * ptr)
{
	int mask = (1 << bitcount) - 1;
	value &= mask;
	ptr += bitoffset >> 3;
	bitoffset &= 7;
	value <<= bitoffset;
	mask <<= bitoffset;
	mask = ~mask;

	ptr[0] &= mask;
	ptr[0] |= value;
	ptr[1] &= mask >> 8;
	ptr[1] |= value >> 8;
}

// routine to read up to 8 bits
static inline int read_bits(int bitcount, int bitoffset, const uint8_t * ptr)
{
	int mask = (1 << bitcount) - 1;
	ptr += bitoffset >> 3;
	bitoffset &= 7;
	int value = ptr[0] | (ptr[1] << 8);
	value >>= bitoffset;
	value &= mask;
	return value;
}

void encode_ise(int quantization_level, int elements, const uint8_t * input_data, uint8_t * output_data, int bit_offset)
{
	int i;
	uint8_t lowparts[64];
	uint8_t highparts[69];		// 64 elements + 5 elements for padding
	uint8_t tq_blocks[22];		// trit-blocks or quint-blocks

	int bits, trits, quints;
	find_number_of_bits_trits_quints(quantization_level, &bits, &trits, &quints);

	for (i = 0; i < elements; i++)
	{
		lowparts[i] = input_data[i] & ((1 << bits) - 1);
		highparts[i] = input_data[i] >> bits;
	}
	for (i = elements; i < elements + 5; i++)
		highparts[i] = 0;		// padding before we start constructing trit-blocks or quint-blocks

	// construct trit-blocks or quint-blocks as necessary
	if (trits)
	{
		int trit_blocks = (elements + 4) / 5;
		for (i = 0; i < trit_blocks; i++)
			tq_blocks[i] = integer_of_trits[highparts[5 * i + 4]][highparts[5 * i + 3]][highparts[5 * i + 2]][highparts[5 * i + 1]][highparts[5 * i]];
	}

	if (quints)
	{
		int quint_blocks = (elements + 2) / 3;
		for (i = 0; i < quint_blocks; i++)
			tq_blocks[i] = integer_of_quints[highparts[3 * i + 2]][highparts[3 * i + 1]][highparts[3 * i]];
	}

	// then, write out the actual bits.
	int lcounter = 0;
	int hcounter = 0;
	for (i = 0; i < elements; i++)
	{
		write_bits(lowparts[i], bits, bit_offset, output_data);
		bit_offset += bits;

		if (trits)
		{
			static const int bits_to_write[5] = { 2, 2, 1, 2, 1 };
			static const int block_shift[5] = { 0, 2, 4, 5, 7 };
			static const int next_lcounter[5] = { 1, 2, 3, 4, 0 };
			static const int hcounter_incr[5] = { 0, 0, 0, 0, 1 };
			write_bits(tq_blocks[hcounter] >> block_shift[lcounter], bits_to_write[lcounter], bit_offset, output_data);
			bit_offset += bits_to_write[lcounter];
			hcounter += hcounter_incr[lcounter];
			lcounter = next_lcounter[lcounter];
		}

		if (quints)
		{
			static const int bits_to_write[3] = { 3, 2, 2 };
			static const int block_shift[3] = { 0, 3, 5 };
			static const int next_lcounter[3] = { 1, 2, 0 };
			static const int hcounter_incr[3] = { 0, 0, 1 };
			write_bits(tq_blocks[hcounter] >> block_shift[lcounter], bits_to_write[lcounter], bit_offset, output_data);
			bit_offset += bits_to_write[lcounter];
			hcounter += hcounter_incr[lcounter];
			lcounter = next_lcounter[lcounter];
		}
	}
}

void decode_ise(int quantization_level, int elements, const uint8_t * input_data, uint8_t * output_data, int bit_offset)
{
	int i;
	// note: due to how the trit/quint-block unpacking is done in this function,
	// we may write more temporary results than the number of outputs
	// The maximum actual number of results is 64 bit, but we keep 4 additional elements
	// of padding.
	uint8_t results[68];
	uint8_t tq_blocks[22];		// trit-blocks or quint-blocks

	int bits, trits, quints;
	find_number_of_bits_trits_quints(quantization_level, &bits, &trits, &quints);

	int lcounter = 0;
	int hcounter = 0;

	// trit-blocks or quint-blocks must be zeroed out before we collect them in the loop below.
	for (i = 0; i < 22; i++)
		tq_blocks[i] = 0;

	// collect bits for each element, as well as bits for any trit-blocks and quint-blocks.
	for (i = 0; i < elements; i++)
	{
		results[i] = read_bits(bits, bit_offset, input_data);
		bit_offset += bits;

		if (trits)
		{
			static const int bits_to_read[5] = { 2, 2, 1, 2, 1 };
			static const int block_shift[5] = { 0, 2, 4, 5, 7 };
			static const int next_lcounter[5] = { 1, 2, 3, 4, 0 };
			static const int hcounter_incr[5] = { 0, 0, 0, 0, 1 };
			int tdata = read_bits(bits_to_read[lcounter], bit_offset, input_data);
			bit_offset += bits_to_read[lcounter];
			tq_blocks[hcounter] |= tdata << block_shift[lcounter];
			hcounter += hcounter_incr[lcounter];
			lcounter = next_lcounter[lcounter];
		}

		if (quints)
		{
			static const int bits_to_read[3] = { 3, 2, 2 };
			static const int block_shift[3] = { 0, 3, 5 };
			static const int next_lcounter[3] = { 1, 2, 0 };
			static const int hcounter_incr[3] = { 0, 0, 1 };
			int tdata = read_bits(bits_to_read[lcounter], bit_offset, input_data);
			bit_offset += bits_to_read[lcounter];
			tq_blocks[hcounter] |= tdata << block_shift[lcounter];
			hcounter += hcounter_incr[lcounter];
			lcounter = next_lcounter[lcounter];
		}
	}

	// unpack trit-blocks or quint-blocks as needed
	if (trits)
	{
		int trit_blocks = (elements + 4) / 5;
		for (i = 0; i < trit_blocks; i++)
		{
			const uint8_t *tritptr = trits_of_integer[tq_blocks[i]];
			results[5 * i] |= tritptr[0] << bits;
			results[5 * i + 1] |= tritptr[1] << bits;
			results[5 * i + 2] |= tritptr[2] << bits;
			results[5 * i + 3] |= tritptr[3] << bits;
			results[5 * i + 4] |= tritptr[4] << bits;
		}
	}

	if (quints)
	{
		int quint_blocks = (elements + 2) / 3;
		for (i = 0; i < quint_blocks; i++)
		{
			const uint8_t *quintptr = quints_of_integer[tq_blocks[i]];
			results[3 * i] |= quintptr[0] << bits;
			results[3 * i + 1] |= quintptr[1] << bits;
			results[3 * i + 2] |= quintptr[2] << bits;
		}
	}

	for (i = 0; i < elements; i++)
		output_data[i] = results[i];
}

int compute_ise_bitcount(int items, quantization_method quant)
{
	switch (quant)
	{
	case QUANT_2:
		return items;
	case QUANT_3:
		return (8 * items + 4) / 5;
	case QUANT_4:
		return 2 * items;
	case QUANT_5:
		return (7 * items + 2) / 3;
	case QUANT_6:
		return (13 * items + 4) / 5;
	case QUANT_8:
		return 3 * items;
	case QUANT_10:
		return (10 * items + 2) / 3;
	case QUANT_12:
		return (18 * items + 4) / 5;
	case QUANT_16:
		return items * 4;
	case QUANT_20:
		return (13 * items + 2) / 3;
	case QUANT_24:
		return (23 * items + 4) / 5;
	case QUANT_32:
		return 5 * items;
	case QUANT_40:
		return (16 * items + 2) / 3;
	case QUANT_48:
		return (28 * items + 4) / 5;
	case QUANT_64:
		return 6 * items;
	case QUANT_80:
		return (19 * items + 2) / 3;
	case QUANT_96:
		return (33 * items + 4) / 5;
	case QUANT_128:
		return 7 * items;
	case QUANT_160:
		return (22 * items + 2) / 3;
	case QUANT_192:
		return (38 * items + 4) / 5;
	case QUANT_256:
		return 8 * items;
	default:
		return 100000;
	}
}