text: // basisu.h
  // Copyright (C) 2019 Binomial LLC. All Rights Reserved.
  // Important: If compiling with gcc, be sure strict aliasing is disabled: -fno-strict-aliasing
  //
  // 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.
  #pragma once
  
  #ifdef _MSC_VER
  
  #pragma warning (disable : 4201)
  #pragma warning (disable : 4127) // warning C4127: conditional expression is constant
  #pragma warning (disable : 4530) // C++ exception handler used, but unwind semantics are not enabled.
  
  #ifndef BASISU_NO_ITERATOR_DEBUG_LEVEL
  //#define _HAS_ITERATOR_DEBUGGING 0
  
  #if defined(_DEBUG) || defined(DEBUG)
  #ifndef _SECURE_SCL
  #define _SECURE_SCL 1
  #endif
  #else // defined(_DEBUG) || defined(DEBUG)
  #ifndef _SECURE_SCL
  			#define _SECURE_SCL 0
  			#endif
  			#ifndef _ITERATOR_DEBUG_LEVEL
  			#define _ITERATOR_DEBUG_LEVEL 0
  			#endif
  #endif // defined(_DEBUG) || defined(DEBUG)
  
  #ifndef NOMINMAX
  #define NOMINMAX
  #endif
  
  #endif // BASISU_NO_ITERATOR_DEBUG_LEVEL
  
  #endif // _MSC_VER
  
  
  #include <stdlib.h>
  #include <stdio.h>
  #include <math.h>
  #include <stdarg.h>
  #include <string.h>
  #include <memory.h>
  #include <limits.h>
  #include <stdint.h>
  #include <assert.h>
  
  #ifdef max
  #undef max
  #endif
  
  #ifdef min
  #undef min
  #endif
  
  #ifdef _WIN32
  #define strcasecmp _stricmp
  #endif
  
  // Set to one to enable debug printf()'s when any errors occur, for development/debugging.
  #ifndef BASISU_DEVEL_MESSAGES
  #define BASISU_DEVEL_MESSAGES 0
  #endif
  
  #define BASISU_NOTE_UNUSED(x) (void)(x)
  #define BASISU_ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
  #define BASISU_NO_EQUALS_OR_COPY_CONSTRUCT(x) x(const x &) = delete; x& operator= (const x &) = delete;
  #define BASISU_ASSUME(x) static_assert(x, #x);
  #define BASISU_OFFSETOF(s, m) (uint32_t)(intptr_t)(&((s *)(0))->m)
  #define BASISU_STRINGIZE(x) #x
  #define BASISU_STRINGIZE2(x) BASISU_STRINGIZE(x)
  
  #if BASISU_DEVEL_MESSAGES
  #define BASISU_DEVEL_ERROR(...) do { basisu::debug_printf(__VA_ARGS__); } while(0)
  #else
  #define BASISU_DEVEL_ERROR(...)
  #endif
  
  namespace basisu {
  // Types/utilities
  template<typename T>
  struct FakeStdVector {
  
  	FakeStdVector(uint64_t s = 0) : vectorCapacity(0), vectorSize(0), data(nullptr) {
  		resize(s);
  	}
  
  	~FakeStdVector() {
  		clear();
  	}
  
  	void resize(uint64_t s) {
  		if (s > vectorCapacity) {
  			data = (T *) MEMORY_REALLOC(data, s * sizeof(T));
  			memset(data + vectorCapacity, 0, (s - vectorCapacity) * sizeof(T));
  			vectorSize = s;
  			vectorCapacity = s;
  		} else {
  			vectorSize = s;
  		}
  	}
  	void clear() {
  		MEMORY_FREE(data);
  		data = nullptr;
  		vectorSize = 0;
  		vectorCapacity = 0;
  	}
  
  	void fast_clear() { vectorSize = 0; }
  
  	uint64_t size() const { return vectorSize; }
  	uint64_t capacity() const { return vectorCapacity; }
  
  	T &operator[](uint64_t index) {
  		return data[index];
  	}
  
  	T const &operator[](uint64_t index) const {
  		return data[index];
  	}
  
  private:
  	uint64_t vectorCapacity;
  	uint64_t vectorSize;
  	T *data;
  };
  
  #ifdef _WIN32
  const char BASISU_PATH_SEPERATOR_CHAR = '\\';
  #else
  const char BASISU_PATH_SEPERATOR_CHAR = '/';
  #endif
  
  typedef FakeStdVector<uint8_t> uint8_vec;
  typedef FakeStdVector<int16_t> int16_vec;
  typedef FakeStdVector<uint16_t> uint16_vec;
  typedef FakeStdVector<uint32_t> uint_vec;
  typedef FakeStdVector<uint64_t> uint64_vec;
  typedef FakeStdVector<int> int_vec;
  typedef FakeStdVector<bool> bool_vec;
  
  void enable_debug_printf(bool enabled);
  void debug_printf(const char *pFmt, ...);
  
  template<typename T> inline void clear_obj(T &obj) { memset(&obj, 0, sizeof(obj)); }
  
  template<typename T0, typename T1> inline T0 lerp(T0 a, T0 b, T1 c) { return a + (b - a) * c; }
  
  template<typename S> inline S maximum(S a, S b) { return (a > b) ? a : b; }
  template<typename S> inline S maximum(S a, S b, S c) { return maximum(maximum(a, b), c); }
  
  template<typename S> inline S minimum(S a, S b) { return (a < b) ? a : b; }
  template<typename S> inline S minimum(S a, S b, S c) { return minimum(minimum(a, b), c); }
  
  template<typename S> inline S clamp(S value, S low, S high) {
  	return (value < low) ? low : ((value > high) ? high : value);
  }
  
  inline uint32_t iabs(int32_t i) { return (i < 0) ? static_cast<uint32_t>(-i) : static_cast<uint32_t>(i); }
  inline uint64_t iabs64(int64_t i) { return (i < 0) ? static_cast<uint64_t>(-i) : static_cast<uint64_t>(i); }
  
  template<typename T> inline void clear_vector(T &vec) { vec.fast_clear(); } //vec.erase(vec.begin(), vec.end()); }
  template<typename T> inline typename T::value_type *enlarge_vector(T &vec, size_t n) {
  	size_t cs = vec.size();
  	vec.resize(cs + n);
  	return &vec[cs];
  }
  
  template<typename S> inline S square(S val) { return val * val; }
  
  inline bool is_pow2(uint32_t x) { return x && ((x & (x - 1U)) == 0U); }
  inline bool is_pow2(uint64_t x) { return x && ((x & (x - 1U)) == 0U); }
  
  template<typename T> inline T open_range_check(T v, T minv, T maxv) {
  	assert(v >= minv && v < maxv);
  	return v;
  }
  template<typename T> inline T open_range_check(T v, T maxv) {
  	assert(v < maxv);
  	BASISU_NOTE_UNUSED(maxv);
  	return v;
  }
  
  inline uint32_t total_bits(uint32_t v) {
  	uint32_t l = 0;
  	for (; v > 0U; ++l)
  		v >>= 1;
  	return l;
  }
  
  template<typename T> inline T saturate(T val) { return clamp(val, 0.0f, 1.0f); }
  
  template<typename T, typename R> inline void append_vector(T &vec, const R *pObjs, size_t n) {
  	if (n) {
  		const size_t cur_s = vec.size();
  		vec.resize(cur_s + n);
  		memcpy(&vec[cur_s], pObjs, sizeof(R) * n);
  	}
  }
  
  template<typename T> inline void append_vector(T &vec, const T &other_vec) {
  	if (other_vec.size()) {
  		append_vector(vec, &other_vec[0], other_vec.size());
  	}
  }
  
  template<typename T> inline void vector_ensure_element_is_valid(T &vec, size_t idx) {
  	if (idx >= vec.size()) {
  		vec.resize(idx + 1);
  	}
  }
  
  template<typename T> inline void vector_sort(T &vec) {
  	if (vec.size()) {
  		std::sort(vec.begin(), vec.end());
  	}
  }
  
  template<typename T, typename U> inline bool unordered_set_contains(T &set, const U &obj) {
  	return set.find(obj) != set.end();
  }
  
  template<typename T> int vector_find(const T &vec, const typename T::value_type &obj) {
  	assert(vec.size() <= INT_MAX);
  	for (size_t i = 0; i < vec.size(); i++)
  		if (vec[i] == obj) {
  			return static_cast<int>(i);
  		}
  	return -1;
  }
  
  template<typename T> void vector_set_all(T &vec, const typename T::value_type &obj) {
  	for (size_t i = 0; i < vec.size(); i++)
  		vec[i] = obj;
  }
  
  inline uint64_t read_be64(const void *p) {
  	uint64_t val = 0;
  	for (uint32_t i = 0; i < 8; i++)
  		val |= (static_cast<uint64_t>(static_cast<const uint8_t *>(p)[7 - i]) << (i * 8));
  	return val;
  }
  
  inline void write_be64(void *p, uint64_t x) {
  	for (uint32_t i = 0; i < 8; i++)
  		static_cast<uint8_t *>(p)[7 - i] = static_cast<uint8_t>(x >> (i * 8));
  }
  
  static inline uint16_t byteswap16(uint16_t x) { return static_cast<uint16_t>((x << 8) | (x >> 8)); }
  static inline uint32_t byteswap32(uint32_t x) {
  	return ((x << 24) | ((x << 8) & 0x00FF0000) | ((x >> 8) & 0x0000FF00) | (x >> 24));
  }
  
  inline uint32_t floor_log2i(uint32_t v) {
  	uint32_t b = 0;
  	for (; v > 1U; ++b)
  		v >>= 1;
  	return b;
  }
  
  inline uint32_t ceil_log2i(uint32_t v) {
  	uint32_t b = floor_log2i(v);
  	if ((b != 32) && (v > (1U << b))) {
  		++b;
  	}
  	return b;
  }
  
  inline int posmod(int x, int y) {
  	if (x >= 0) {
  		return (x < y) ? x : (x % y);
  	}
  	int m = (-x) % y;
  	return (m != 0) ? (y - m) : m;
  }
  
  inline bool do_excl_ranges_overlap(int la, int ha, int lb, int hb) {
  	assert(la < ha && lb < hb);
  	if ((ha <= lb) || (la >= hb)) {
  		return false;
  	}
  	return true;
  }
  
  // Always little endian 2-4 byte unsigned int
  template<uint32_t NumBytes>
  struct packed_uint {
  	uint8_t m_bytes[NumBytes];
  
  	inline packed_uint() { static_assert(NumBytes <= 4, "NumBytes <= 4"); }
  	inline packed_uint(uint32_t v) { *this = v; }
  	inline packed_uint(const packed_uint &other) { *this = other; }
  
  	inline packed_uint &operator=(uint32_t v) {
  		for (uint32_t i = 0; i < NumBytes; i++)
  			m_bytes[i] = static_cast<uint8_t>(v >> (i * 8));
  		return *this;
  	}
  
  	inline operator uint32_t() const {
  		switch (NumBytes) {
  			case 1: return m_bytes[0];
  			case 2: return (m_bytes[1] << 8U) | m_bytes[0];
  			case 3: return (m_bytes[2] << 16U) | (m_bytes[1] << 8U) | (m_bytes[0]);
  			default: return (m_bytes[3] << 24U) | (m_bytes[2] << 16U) | (m_bytes[1] << 8U) | (m_bytes[0]);
  		}
  	}
  };
  
  enum eZero { cZero };
  enum eNoClamp { cNoClamp };
  
  // Rice/Huffman entropy coding
  
  // This is basically Deflate-style canonical Huffman, except we allow for a lot more symbols.
  enum {
  	cHuffmanMaxSupportedCodeSize = 16,
  	cHuffmanMaxSupportedInternalCodeSize = 31,
  	cHuffmanFastLookupBits = 10,
  	cHuffmanFastLookupSize = 1 << cHuffmanFastLookupBits,
  	cHuffmanMaxSymsLog2 = 14,
  	cHuffmanMaxSyms = 1 << cHuffmanMaxSymsLog2,
  
  	// Small zero runs
  			cHuffmanSmallZeroRunSizeMin = 3,
  	cHuffmanSmallZeroRunSizeMax = 10,
  	cHuffmanSmallZeroRunExtraBits = 3,
  
  	// Big zero run
  			cHuffmanBigZeroRunSizeMin = 11,
  	cHuffmanBigZeroRunSizeMax = 138,
  	cHuffmanBigZeroRunExtraBits = 7,
  
  	// Small non-zero run
  			cHuffmanSmallRepeatSizeMin = 3,
  	cHuffmanSmallRepeatSizeMax = 6,
  	cHuffmanSmallRepeatExtraBits = 2,
  
  	// Big non-zero run
  			cHuffmanBigRepeatSizeMin = 7,
  	cHuffmanBigRepeatSizeMax = 134,
  	cHuffmanBigRepeatExtraBits = 7,
  
  	cHuffmanTotalCodelengthCodes = 21,
  	cHuffmanSmallZeroRunCode = 17,
  	cHuffmanBigZeroRunCode = 18,
  	cHuffmanSmallRepeatCode = 19,
  	cHuffmanBigRepeatCode = 20
  };
  
  static const uint8_t g_huffman_sorted_codelength_codes[] =
  		{cHuffmanSmallZeroRunCode, cHuffmanBigZeroRunCode, cHuffmanSmallRepeatCode, cHuffmanBigRepeatCode, 0, 8, 7, 9, 6,
  		 0xA, 5, 0xB, 4, 0xC, 3, 0xD, 2, 0xE, 1, 0xF, 0x10};
  const uint32_t cHuffmanTotalSortedCodelengthCodes =
  		sizeof(g_huffman_sorted_codelength_codes) / sizeof(g_huffman_sorted_codelength_codes[0]);
  
  // GPU texture formats
  
  enum texture_format {
  	cInvalidTextureFormat = -1,
  
  	// Block-based formats
  			cETC1,      // ETC1
  	cETC1S,      // ETC1 (subset: diff colors only, no subblocks)
  	cETC2_RGB,    // ETC2 color block
  	cETC2_RGBA,    // ETC2 alpha block followed by ETC2 color block
  	cETC2_ALPHA,  // ETC2 EAC alpha block
  	cBC1,        // DXT1
  	cBC3,        // DXT5 (DXT5A block followed by a DXT1 block)
  	cBC4,        // DXT5A
  	cBC5,        // 3DC/DXN (two DXT5A blocks)
  	cBC7,
  	cASTC4x4,
  	cPVRTC1_4_RGB,
  	cPVRTC1_4_RGBA,
  	cATC_RGB,
  	cATC_RGBA_INTERPOLATED_ALPHA,
  
  	// Uncompressed/raw pixels
  			cRGBA32,
  	cRGB565,
  	cBGR565,
  	cRGBA4444,
  	cABGR4444
  };
  
  inline uint32_t get_bytes_per_block(texture_format fmt) {
  	switch (fmt) {
  		case cETC1:
  		case cETC1S:
  		case cETC2_RGB:
  		case cETC2_ALPHA:
  		case cBC1:
  		case cBC4:
  		case cPVRTC1_4_RGB:
  		case cPVRTC1_4_RGBA:
  		case cATC_RGB: return 8;
  		case cRGBA32: return sizeof(uint32_t) * 16;
  		default: break;
  	}
  	return 16;
  }
  
  inline uint32_t get_qwords_per_block(texture_format fmt) {
  	return get_bytes_per_block(fmt) >> 3;
  }
  
  inline uint32_t get_block_width(texture_format fmt) {
  	BASISU_NOTE_UNUSED(fmt);
  	return 4;
  }
  
  inline uint32_t get_block_height(texture_format fmt) {
  	BASISU_NOTE_UNUSED(fmt);
  	return 4;
  }
  
  } // namespace basisu
  
  