Add external libs.

extern/atitc/ATI_Compress.h

@@ -0,0 +1,175 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Advanced Micro Devices, Inc.
+//  1 AMD Place
+//  Sunnyvale, CA
+//  USA 94088
+//
+//  File Name:   ATI_Compress.h
+//  Description: A library to compress/decompress textures
+//
+//  Copyright (c) 2007,2008 Advanced Micro Devices, Inc.
+//  Copyright (c) 2004-2006 ATI Technologies Inc.
+//
+//  Version:	1.7
+//
+//  Developer:	Seth Sowerby	
+//  Email:		gputools.support@amd.com
+//
+//////////////////////////////////////////////////////////////////////////////
+
+/// \file
+/// ATI_Compress.h declares the interface to the ATI_Compress library.
+
+#ifndef ATI_COMPRESS
+#define ATI_COMPRESS
+
+#define ATI_COMPRESS_VERSION_MAJOR 1         ///< The major version number of this release.
+#define ATI_COMPRESS_VERSION_MINOR 7         ///< The minor version number of this release.
+
+typedef unsigned long ATI_TC_DWORD;          ///< A 32-bit integer format.
+typedef unsigned short ATI_TC_WORD;          ///< A 16-bit integer format.
+typedef unsigned char ATI_TC_BYTE;           ///< An 8-bit integer format.
+
+#if defined(WIN32) || defined(_WIN64)
+#   define ATI_TC_API __cdecl
+#else
+#   define ATI_TC_API 
+#endif
+
+#ifdef ATI_COMPRESS_INTERNAL_BUILD
+#   include "ATI_Compress_Internal.h"
+#else // ATI_COMPRESS_INTERNAL_BUILD
+
+/// Texture format.
+typedef enum
+{
+   ATI_TC_FORMAT_Unknown,                    ///< An undefined texture format.
+   ATI_TC_FORMAT_ARGB_8888,                  ///< An ARGB format with 8-bit fixed channels.
+   ATI_TC_FORMAT_RGB_888,                    ///< A RGB format with 8-bit fixed channels.
+   ATI_TC_FORMAT_RG_8,                       ///< A two component format with 8-bit fixed channels.
+   ATI_TC_FORMAT_R_8,                        ///< A single component format with 8-bit fixed channels.
+   ATI_TC_FORMAT_ARGB_2101010,               ///< An ARGB format with 10-bit fixed channels for color & a 2-bit fixed channel for alpha.
+   ATI_TC_FORMAT_ARGB_16,                    ///< A ARGB format with 16-bit fixed channels.
+   ATI_TC_FORMAT_RG_16,                      ///< A two component format with 16-bit fixed channels.
+   ATI_TC_FORMAT_R_16,                       ///< A single component format with 16-bit fixed channels.
+   ATI_TC_FORMAT_ARGB_16F,                   ///< An ARGB format with 16-bit floating-point channels.
+   ATI_TC_FORMAT_RG_16F,                     ///< A two component format with 16-bit floating-point channels.
+   ATI_TC_FORMAT_R_16F,                      ///< A single component with 16-bit floating-point channels.
+   ATI_TC_FORMAT_ARGB_32F,                   ///< An ARGB format with 32-bit floating-point channels.
+   ATI_TC_FORMAT_RG_32F,                     ///< A two component format with 32-bit floating-point channels.
+   ATI_TC_FORMAT_R_32F,                      ///< A single component with 32-bit floating-point channels.
+   ATI_TC_FORMAT_DXT1,                       ///< An opaque (or 1-bit alpha) DXTC compressed texture format. Four bits per pixel.
+   ATI_TC_FORMAT_DXT3,                       ///< A DXTC compressed texture format with explicit alpha. Eight bits per pixel.
+   ATI_TC_FORMAT_DXT5,                       ///< A DXTC compressed texture format with interpolated alpha. Eight bits per pixel.
+   ATI_TC_FORMAT_DXT5_xGBR,                  ///< A DXT5 with the red component swizzled into the alpha channel. Eight bits per pixel.
+   ATI_TC_FORMAT_DXT5_RxBG,                  ///< A swizzled DXT5 format with the green component swizzled into the alpha channel. Eight bits per pixel.
+   ATI_TC_FORMAT_DXT5_RBxG,                  ///< A swizzled DXT5 format with the green component swizzled into the alpha channel & the blue component swizzled into the green channel. Eight bits per pixel.
+   ATI_TC_FORMAT_DXT5_xRBG,                  ///< A swizzled DXT5 format with the green component swizzled into the alpha channel & the red component swizzled into the green channel. Eight bits per pixel.
+   ATI_TC_FORMAT_DXT5_RGxB,                  ///< A swizzled DXT5 format with the blue component swizzled into the alpha channel. Eight bits per pixel.
+   ATI_TC_FORMAT_DXT5_xGxR,                  ///< A two-component swizzled DXT5 format with the red component swizzled into the alpha channel & the green component in the green channel. Eight bits per pixel.
+   ATI_TC_FORMAT_ATI1N,                      ///< A single component compression format using the same technique as DXT5 alpha. Four bits per pixel.
+   ATI_TC_FORMAT_ATI2N,                      ///< A two component compression format using the same technique as DXT5 alpha. Designed for compression object space normal maps. Eight bits per pixel.
+   ATI_TC_FORMAT_ATI2N_XY,                   ///< A two component compression format using the same technique as DXT5 alpha. The same as ATI2N but with the channels swizzled. Eight bits per pixel.
+   ATI_TC_FORMAT_ATI2N_DXT5,                 ///< An ATI2N like format using DXT5. Intended for use on GPUs that do not natively support ATI2N. Eight bits per pixel.
+   ATI_TC_FORMAT_BC1,                        ///< A four component opaque (or 1-bit alpha) compressed texture format for Microsoft DirectX10. Identical to DXT1.  Four bits per pixel.
+   ATI_TC_FORMAT_BC2,                        ///< A four component compressed texture format with explicit alpha for Microsoft DirectX10. Identical to DXT3. Eight bits per pixel.
+   ATI_TC_FORMAT_BC3,                        ///< A four component compressed texture format with interpolated alpha for Microsoft DirectX10. Identical to DXT5. Eight bits per pixel.
+   ATI_TC_FORMAT_BC4,                        ///< A single component compressed texture format for Microsoft DirectX10. Identical to ATI1N. Four bits per pixel.
+   ATI_TC_FORMAT_BC5,                        ///< A two component compressed texture format for Microsoft DirectX10. Identical to ATI2N. Eight bits per pixel.
+   ATI_TC_FORMAT_ATC_RGB,                    ///< ATI_TC - a compressed RGB format for cellphones & hand-held devices.
+   ATI_TC_FORMAT_ATC_RGBA_Explicit,          ///< ATI_TC - a compressed ARGB format with explicit alpha for cellphones & hand-held devices.  
+   ATI_TC_FORMAT_ATC_RGBA_Interpolated,      ///< ATI_TC - a compressed ARGB format with interpolated alpha for cellphones & hand-held devices. 
+   ATI_TC_FORMAT_ETC_RGB,                    ///< ETC (aka Ericsson Texture Compression) - a compressed RGB format for cellphones.
+   ATI_TC_FORMAT_MAX = ATI_TC_FORMAT_ETC_RGB
+} ATI_TC_FORMAT;
+
+/// An enum selecting the speed vs. quality trade-off.
+typedef enum
+{
+   ATI_TC_Speed_Normal,                      ///< Highest quality mode
+   ATI_TC_Speed_Fast,                        ///< Slightly lower quality but much faster compression mode - DXTn & ATInN only
+   ATI_TC_Speed_SuperFast,                   ///< Slightly lower quality but much, much faster compression mode - DXTn & ATInN only
+} ATI_TC_Speed;
+
+/// ATI_Compress error codes
+typedef enum
+{
+   ATI_TC_OK = 0,                            ///< Ok.
+   ATI_TC_ABORTED,                           ///< The conversion was aborted.
+   ATI_TC_ERR_INVALID_SOURCE_TEXTURE,        ///< The source texture is invalid.
+   ATI_TC_ERR_INVALID_DEST_TEXTURE,          ///< The destination texture is invalid.
+   ATI_TC_ERR_UNSUPPORTED_SOURCE_FORMAT,     ///< The source format is not a supported format.
+   ATI_TC_ERR_UNSUPPORTED_DEST_FORMAT,       ///< The destination format is not a supported format.
+   ATI_TC_ERR_SIZE_MISMATCH,                 ///< The source and destination texture sizes do not match.
+   ATI_TC_ERR_UNABLE_TO_INIT_CODEC,          ///< ATI_Compress was unable to initialize the codec needed for conversion.
+   ATI_TC_ERR_GENERIC                        ///< An unknown error occurred.
+} ATI_TC_ERROR;
+
+/// Options for the compression.
+/// Passing this structure is optional
+typedef struct
+{
+   ATI_TC_DWORD	dwSize;					      ///< The size of this structure.
+   BOOL			   bUseChannelWeighting;      ///< Use channel weightings. With swizzled formats the weighting applies to the data within the specified channel not the channel itself.
+   double			fWeightingRed;			      ///< The weighting of the Red or X Channel.
+   double			fWeightingGreen;		      ///< The weighting of the Green or Y Channel.
+   double			fWeightingBlue;		      ///< The weighting of the Blue or Z Channel.
+   BOOL			   bUseAdaptiveWeighting;     ///< Adapt weighting on a per-block basis.
+   BOOL			   bDXT1UseAlpha;             ///< Encode single-bit alpha data. Only valid when compressing to DXT1 & BC1.
+   ATI_TC_BYTE		nAlphaThreshold;           ///< The alpha threshold to use when compressing to DXT1 & BC1 with bDXT1UseAlpha. Texels with an alpha value less than the threshold are treated as transparent.
+   BOOL			   bDisableMultiThreading;    ///< Disable multi-threading of the compression. This will slow the compression but can be useful if you're managing threads in your application.
+   ATI_TC_Speed   nCompressionSpeed;         ///< The trade-off between compression speed & quality.
+} ATI_TC_CompressOptions;
+#endif // !ATI_COMPRESS_INTERNAL_BUILD
+
+/// The structure describing a texture.
+typedef struct
+{
+   ATI_TC_DWORD   dwSize;                    ///< Size of this structure.
+   ATI_TC_DWORD	dwWidth;                   ///< Width of the texture.
+   ATI_TC_DWORD	dwHeight;                  ///< Height of the texture.
+   ATI_TC_DWORD	dwPitch;                   ///< Distance to start of next line - necessary only for uncompressed textures.
+   ATI_TC_FORMAT	format;                    ///< Format of the texture.
+   ATI_TC_DWORD	dwDataSize;                ///< Size of the allocated texture data.
+   ATI_TC_BYTE*	pData;                     ///< Pointer to the texture data
+} ATI_TC_Texture;
+
+#define MINIMUM_WEIGHT_VALUE 0.01f
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+   /// ATI_TC_Feedback_Proc
+   /// Feedback function for conversion.
+   /// \param[in] fProgress The percentage progress of the texture compression.
+   /// \param[in] pUser1 User data as passed to ATI_TC_ConvertTexture.
+   /// \param[in] pUser2 User data as passed to ATI_TC_ConvertTexture.
+   /// \return non-NULL(true) value to abort conversion
+   typedef bool (ATI_TC_API * ATI_TC_Feedback_Proc)(float fProgress, DWORD_PTR pUser1, DWORD_PTR pUser2);
+
+   /// Calculates the required buffer size for the specified texture
+   /// \param[in] pTexture A pointer to the texture.
+   /// \return    The size of the buffer required to hold the texture data.
+   ATI_TC_DWORD ATI_TC_API ATI_TC_CalculateBufferSize(const ATI_TC_Texture* pTexture);
+
+   /// Converts the source texture to the destination texture
+   /// This can be compression, decompression or converting between two uncompressed formats.
+   /// \param[in] pSourceTexture A pointer to the source texture.
+   /// \param[in] pDestTexture A pointer to the destination texture.
+   /// \param[in] pOptions A pointer to the compression options - can be NULL.
+   /// \param[in] pFeedbackProc A pointer to the feedback function - can be NULL.
+   /// \param[in] pUser1 User data to pass to the feedback function.
+   /// \param[in] pUser2 User data to pass to the feedback function.
+   /// \return    ATI_TC_OK if successful, otherwise the error code.
+   ATI_TC_ERROR ATI_TC_API ATI_TC_ConvertTexture(const ATI_TC_Texture* pSourceTexture, ATI_TC_Texture* pDestTexture, 
+                                                 const ATI_TC_CompressOptions* pOptions, 
+                                                 ATI_TC_Feedback_Proc pFeedbackProc, DWORD_PTR pUser1, DWORD_PTR pUser2);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif // !ATI_COMPRESS

extern/stb/stb_dxt.h

@@ -0,0 +1,555 @@
+// stb_dxt.h - v1.03 - DXT1/DXT5 compressor - public domain
+// original by fabian "ryg" giesen - ported to C by stb
+// use '#define STB_DEFINE' before including to create the implementation
+//
+// USAGE:
+//   call stb_compress_dxt_block() for every block (you must pad)
+//     source should be a 4x4 block of RGBA data in row-major order;
+//     A is ignored if you specify alpha=0; you get dithering if
+//     quality=1
+//
+// version history:
+//   v1.03  - endianness support
+//   v1.02  - fix alpha encoding bug
+//   v1.01  - fix bug converting to RGB that messed up quality, thanks ryg & cbloom
+//   v1.00  - first release
+
+#ifndef STB_INCLUDE_STB_DXT_H
+#define STB_INCLUDE_STB_DXT_H
+
+void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int quality);
+#define STB_COMPRESS_DXT_BLOCK
+
+#ifdef STB_DEFINE
+
+#include <stdlib.h>
+#include <math.h>
+#include <string.h> // memset
+
+static unsigned char stb__Expand5[32];
+static unsigned char stb__Expand6[64];
+static unsigned char stb__OMatch5[256][2];
+static unsigned char stb__OMatch6[256][2];
+static unsigned char stb__QuantRBTab[256+16];
+static unsigned char stb__QuantGTab[256+16];
+
+static int stb__Mul8Bit(int a,int b)
+{
+  int t = a*b + 128;
+  return (t + (t >> 8)) >> 8;
+}
+
+static void stb__From16Bit(unsigned char *out, unsigned short v)
+{
+   int rv = (v & 0xf800) >> 11;
+   int gv = (v & 0x07e0) >>  5;
+   int bv = (v & 0x001f) >>  0;
+
+   out[0] = stb__Expand5[rv];
+   out[1] = stb__Expand6[gv];
+   out[2] = stb__Expand5[bv];
+   out[3] = 0;
+}
+
+static unsigned short stb__As16Bit(int r, int g, int b)
+{
+   return (stb__Mul8Bit(r,31) << 11) + (stb__Mul8Bit(g,63) << 5) + stb__Mul8Bit(b,31);
+}
+
+static void stb__LerpRGB(unsigned char *out, unsigned char *p1, unsigned char *p2, int f)
+{
+   out[0] = p1[0] + stb__Mul8Bit(p2[0] - p1[0],f);
+   out[1] = p1[1] + stb__Mul8Bit(p2[1] - p1[1],f);
+   out[2] = p1[2] + stb__Mul8Bit(p2[2] - p1[2],f);
+}
+
+/****************************************************************************/
+
+// compute table to reproduce constant colors as accurately as possible
+static void stb__PrepareOptTable(unsigned char *Table,const unsigned char *expand,int size)
+{
+   int i,mn,mx;
+   for (i=0;i<256;i++) {
+      int bestErr = 256;
+      for (mn=0;mn<size;mn++) {
+         for (mx=0;mx<size;mx++) {
+            int mine = expand[mn];
+            int maxe = expand[mx];
+            int err = abs(maxe + stb__Mul8Bit(mine-maxe,0x55) - i);
+
+            if(err < bestErr)
+            { 
+               Table[i*2+0] = mx;
+               Table[i*2+1] = mn;
+               bestErr = err;
+            }
+         }
+      }
+   }
+}
+
+static void stb__EvalColors(unsigned char *color,unsigned short c0,unsigned short c1)
+{
+   stb__From16Bit(color+ 0, c0);
+   stb__From16Bit(color+ 4, c1);
+   stb__LerpRGB  (color+ 8, color+0,color+4, 0x55);
+   stb__LerpRGB  (color+12, color+0,color+4, 0xaa);
+}
+
+// Block dithering function. Simply dithers a block to 565 RGB.
+// (Floyd-Steinberg)
+static void stb__DitherBlock(unsigned char *dest, unsigned char *block)
+{
+  int err[8],*ep1 = err,*ep2 = err+4, *et;
+  int ch,y;
+
+  // process channels seperately
+  for (ch=0; ch<3; ++ch) {
+      unsigned char *bp = block+ch, *dp = dest+ch;
+      unsigned char *quant = (ch == 1) ? stb__QuantGTab+8 : stb__QuantRBTab+8;
+      memset(err, 0, sizeof(err));
+      for(y=0; y<4; ++y) {
+         dp[ 0] = quant[bp[ 0] + ((3*ep2[1] + 5*ep2[0]) >> 4)];
+         ep1[0] = bp[ 0] - dp[ 0];
+         dp[ 4] = quant[bp[ 4] + ((7*ep1[0] + 3*ep2[2] + 5*ep2[1] + ep2[0]) >> 4)];
+         ep1[1] = bp[ 4] - dp[ 4];
+         dp[ 8] = quant[bp[ 8] + ((7*ep1[1] + 3*ep2[3] + 5*ep2[2] + ep2[1]) >> 4)];
+         ep1[2] = bp[ 8] - dp[ 8];
+         dp[12] = quant[bp[12] + ((7*ep1[2] + 5*ep2[3] + ep2[2]) >> 4)];
+         ep1[3] = bp[12] - dp[12];
+         bp += 16;
+         dp += 16;
+         et = ep1, ep1 = ep2, ep2 = et; // swap
+      }
+   }
+}
+
+// The color matching function
+static unsigned int stb__MatchColorsBlock(unsigned char *block, unsigned char *color,int dither)
+{
+   unsigned int mask = 0;
+   int dirr = color[0*4+0] - color[1*4+0];
+   int dirg = color[0*4+1] - color[1*4+1];
+   int dirb = color[0*4+2] - color[1*4+2];
+   int dots[16];
+   int stops[4];
+   int i;
+   int c0Point, halfPoint, c3Point;
+
+   for(i=0;i<16;i++)
+      dots[i] = block[i*4+0]*dirr + block[i*4+1]*dirg + block[i*4+2]*dirb;
+
+   for(i=0;i<4;i++)
+      stops[i] = color[i*4+0]*dirr + color[i*4+1]*dirg + color[i*4+2]*dirb;
+
+   c0Point   = (stops[1] + stops[3]) >> 1;
+   halfPoint = (stops[3] + stops[2]) >> 1;
+   c3Point   = (stops[2] + stops[0]) >> 1;
+
+   if(!dither) {
+      // the version without dithering is straightforward
+      for (i=15;i>=0;i--) {
+         int dot = dots[i];
+         mask <<= 2;
+
+         if(dot < halfPoint)
+           mask |= (dot < c0Point) ? 1 : 3;
+         else
+           mask |= (dot < c3Point) ? 2 : 0;
+      }
+  } else {
+      // with floyd-steinberg dithering
+      int err[8],*ep1 = err,*ep2 = err+4;
+      int *dp = dots, y;
+
+      c0Point   <<= 4;
+      halfPoint <<= 4;
+      c3Point   <<= 4;
+      for(i=0;i<8;i++)
+         err[i] = 0;
+
+      for(y=0;y<4;y++)
+      {
+         int dot,lmask,step;
+
+         dot = (dp[0] << 4) + (3*ep2[1] + 5*ep2[0]);
+         if(dot < halfPoint)
+           step = (dot < c0Point) ? 1 : 3;
+         else
+           step = (dot < c3Point) ? 2 : 0;
+         ep1[0] = dp[0] - stops[step];
+         lmask = step;
+
+         dot = (dp[1] << 4) + (7*ep1[0] + 3*ep2[2] + 5*ep2[1] + ep2[0]);
+         if(dot < halfPoint)
+           step = (dot < c0Point) ? 1 : 3;
+         else
+           step = (dot < c3Point) ? 2 : 0;
+         ep1[1] = dp[1] - stops[step];
+         lmask |= step<<2;
+
+         dot = (dp[2] << 4) + (7*ep1[1] + 3*ep2[3] + 5*ep2[2] + ep2[1]);
+         if(dot < halfPoint)
+           step = (dot < c0Point) ? 1 : 3;
+         else
+           step = (dot < c3Point) ? 2 : 0;
+         ep1[2] = dp[2] - stops[step];
+         lmask |= step<<4;
+
+         dot = (dp[3] << 4) + (7*ep1[2] + 5*ep2[3] + ep2[2]);
+         if(dot < halfPoint)
+           step = (dot < c0Point) ? 1 : 3;
+         else
+           step = (dot < c3Point) ? 2 : 0;
+         ep1[3] = dp[3] - stops[step];
+         lmask |= step<<6;
+
+         dp += 4;
+         mask |= lmask << (y*8);
+         { int *et = ep1; ep1 = ep2; ep2 = et; } // swap
+      }
+   }
+
+   return mask;
+}
+
+// The color optimization function. (Clever code, part 1)
+static void stb__OptimizeColorsBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16)
+{
+  int mind = 0x7fffffff,maxd = -0x7fffffff;
+  unsigned char *minp, *maxp;
+  double magn;
+  int v_r,v_g,v_b;
+  static const int nIterPower = 4;
+  float covf[6],vfr,vfg,vfb;
+
+  // determine color distribution
+  int cov[6];
+  int mu[3],min[3],max[3];
+  int ch,i,iter;
+
+  for(ch=0;ch<3;ch++)
+  {
+    const unsigned char *bp = ((const unsigned char *) block) + ch;
+    int muv,minv,maxv;
+
+    muv = minv = maxv = bp[0];
+    for(i=4;i<64;i+=4)
+    {
+      muv += bp[i];
+      if (bp[i] < minv) minv = bp[i];
+      else if (bp[i] > maxv) maxv = bp[i];
+    }
+
+    mu[ch] = (muv + 8) >> 4;
+    min[ch] = minv;
+    max[ch] = maxv;
+  }
+
+  // determine covariance matrix
+  for (i=0;i<6;i++)
+     cov[i] = 0;
+
+  for (i=0;i<16;i++)
+  {
+    int r = block[i*4+0] - mu[0];
+    int g = block[i*4+1] - mu[1];
+    int b = block[i*4+2] - mu[2];
+
+    cov[0] += r*r;
+    cov[1] += r*g;
+    cov[2] += r*b;
+    cov[3] += g*g;
+    cov[4] += g*b;
+    cov[5] += b*b;
+  }
+
+  // convert covariance matrix to float, find principal axis via power iter
+  for(i=0;i<6;i++)
+    covf[i] = cov[i] / 255.0f;
+
+  vfr = (float) (max[0] - min[0]);
+  vfg = (float) (max[1] - min[1]);
+  vfb = (float) (max[2] - min[2]);
+
+  for(iter=0;iter<nIterPower;iter++)
+  {
+    float r = vfr*covf[0] + vfg*covf[1] + vfb*covf[2];
+    float g = vfr*covf[1] + vfg*covf[3] + vfb*covf[4];
+    float b = vfr*covf[2] + vfg*covf[4] + vfb*covf[5];
+
+    vfr = r;
+    vfg = g;
+    vfb = b;
+  }
+
+  magn = fabs(vfr);
+  if (fabs(vfg) > magn) magn = fabs(vfg);
+  if (fabs(vfb) > magn) magn = fabs(vfb);
+
+   if(magn < 4.0f) { // too small, default to luminance
+      v_r = 148;
+      v_g = 300;
+      v_b = 58;
+   } else {
+      magn = 512.0 / magn;
+      v_r = (int) (vfr * magn);
+      v_g = (int) (vfg * magn);
+      v_b = (int) (vfb * magn);
+   }
+
+   // Pick colors at extreme points
+   for(i=0;i<16;i++)
+   {
+      int dot = block[i*4+0]*v_r + block[i*4+1]*v_g + block[i*4+2]*v_b;
+
+      if (dot < mind) {
+         mind = dot;
+         minp = block+i*4;
+      }
+
+      if (dot > maxd) {
+         maxd = dot;
+         maxp = block+i*4;
+      }
+   }
+
+   *pmax16 = stb__As16Bit(maxp[0],maxp[1],maxp[2]);
+   *pmin16 = stb__As16Bit(minp[0],minp[1],minp[2]);
+}
+
+static int stb__sclamp(float y, int p0, int p1)
+{
+   int x = (int) y;
+   if (x < p0) return p0;
+   if (x > p1) return p1;
+   return x;
+}
+
+// The refinement function. (Clever code, part 2)
+// Tries to optimize colors to suit block contents better.
+// (By solving a least squares system via normal equations+Cramer's rule)
+static int stb__RefineBlock(unsigned char *block, unsigned short *pmax16, unsigned short *pmin16, unsigned int mask)
+{
+   static const int w1Tab[4] = { 3,0,2,1 };
+   static const int prods[4] = { 0x090000,0x000900,0x040102,0x010402 };
+   // ^some magic to save a lot of multiplies in the accumulating loop...
+
+   float frb,fg;
+   unsigned short oldMin, oldMax, min16, max16;
+   int i, akku = 0, xx,xy,yy;
+   int At1_r,At1_g,At1_b;
+   int At2_r,At2_g,At2_b;
+   unsigned int cm = mask;
+
+   oldMin = *pmin16;
+   oldMax = *pmax16;
+
+   if((mask ^ (mask<<2)) < 4) // all pixels have the same index?
+   {
+      // yes, linear system would be singular; solve using optimal
+      // single-color match on average color
+      int r = 8, g = 8, b = 8;
+      for (i=0;i<16;++i) {
+         r += block[i*4+0];
+         g += block[i*4+1];
+         b += block[i*4+2];
+      }
+
+      r >>= 4; g >>= 4; b >>= 4;
+
+      max16 = (stb__OMatch5[r][0]<<11) | (stb__OMatch6[g][0]<<5) | stb__OMatch5[b][0];
+      min16 = (stb__OMatch5[r][1]<<11) | (stb__OMatch6[g][1]<<5) | stb__OMatch5[b][1];
+   } else {
+      At1_r = At1_g = At1_b = 0;
+      At2_r = At2_g = At2_b = 0;
+      for (i=0;i<16;++i,cm>>=2) {
+         int step = cm&3;
+         int w1 = w1Tab[step];
+         int r = block[i*4+0];
+         int g = block[i*4+1];
+         int b = block[i*4+2];
+
+         akku    += prods[step];
+         At1_r   += w1*r;
+         At1_g   += w1*g;
+         At1_b   += w1*b;
+         At2_r   += r;
+         At2_g   += g;
+         At2_b   += b;
+      }
+
+      At2_r = 3*At2_r - At1_r;
+      At2_g = 3*At2_g - At1_g;
+      At2_b = 3*At2_b - At1_b;
+
+      // extract solutions and decide solvability
+      xx = akku >> 16;
+      yy = (akku >> 8) & 0xff;
+      xy = (akku >> 0) & 0xff;
+
+      frb = 3.0f * 31.0f / 255.0f / (xx*yy - xy*xy);
+      fg = frb * 63.0f / 31.0f;
+
+      // solve.
+      max16 =   stb__sclamp((At1_r*yy - At2_r*xy)*frb+0.5f,0,31) << 11;
+      max16 |=  stb__sclamp((At1_g*yy - At2_g*xy)*fg +0.5f,0,63) << 5;
+      max16 |=  stb__sclamp((At1_b*yy - At2_b*xy)*frb+0.5f,0,31) << 0;
+
+      min16 =   stb__sclamp((At2_r*xx - At1_r*xy)*frb+0.5f,0,31) << 11;
+      min16 |=  stb__sclamp((At2_g*xx - At1_g*xy)*fg +0.5f,0,63) << 5;
+      min16 |=  stb__sclamp((At2_b*xx - At1_b*xy)*frb+0.5f,0,31) << 0;
+   }
+
+   *pmin16 = min16;
+   *pmax16 = max16;
+   return oldMin != min16 || oldMax != max16;
+}
+
+// Color block compression
+static void stb__CompressColorBlock(unsigned char *dest, unsigned char *block,int quality)
+{
+   unsigned int mask;
+   int i;
+   unsigned short max16, min16;
+   unsigned char dblock[16*4],color[4*4];
+
+   // check if block is constant
+   for (i=1;i<16;i++)
+      if (((unsigned int *) block)[i] != ((unsigned int *) block)[0])
+         break;
+
+   if(i == 16) { // constant color
+      int r = block[0], g = block[1], b = block[2];
+      mask  = 0xaaaaaaaa;
+      max16 = (stb__OMatch5[r][0]<<11) | (stb__OMatch6[g][0]<<5) | stb__OMatch5[b][0];
+      min16 = (stb__OMatch5[r][1]<<11) | (stb__OMatch6[g][1]<<5) | stb__OMatch5[b][1];
+   } else {
+      // first step: compute dithered version for PCA if desired
+      if(quality)
+         stb__DitherBlock(dblock,block);
+
+      // second step: pca+map along principal axis
+      stb__OptimizeColorsBlock(quality ? dblock : block,&max16,&min16);
+      if (max16 != min16) {
+         stb__EvalColors(color,max16,min16);
+         mask = stb__MatchColorsBlock(block,color,quality != 0);
+      } else
+         mask = 0;
+
+      // third step: refine
+      if (stb__RefineBlock(quality ? dblock : block,&max16,&min16,mask)) {
+         if (max16 != min16) {
+            stb__EvalColors(color,max16,min16);
+            mask = stb__MatchColorsBlock(block,color,quality != 0);
+         } else
+            mask = 0;
+      }
+  }
+
+  // write the color block
+  if(max16 < min16)
+  {
+     unsigned short t = min16;
+     min16 = max16;
+     max16 = t;
+     mask ^= 0x55555555;
+  }
+
+  dest[0] = (unsigned char) (max16);
+  dest[1] = (unsigned char) (max16 >> 8);
+  dest[2] = (unsigned char) (min16);
+  dest[3] = (unsigned char) (min16 >> 8);
+  dest[4] = (unsigned char) (mask);
+  dest[5] = (unsigned char) (mask >> 8);
+  dest[6] = (unsigned char) (mask >> 16);
+  dest[7] = (unsigned char) (mask >> 24);
+}
+
+// Alpha block compression (this is easy for a change)
+static void stb__CompressAlphaBlock(unsigned char *dest,unsigned char *src,int quality)
+{
+   int i,dist,bias,dist4,dist2,bits,mask;
+
+   // find min/max color
+   int mn,mx;
+   mn = mx = src[3];
+
+   for (i=1;i<16;i++)
+   {
+      if (src[i*4+3] < mn) mn = src[i*4+3];
+      else if (src[i*4+3] > mx) mx = src[i*4+3];
+   }
+
+   // encode them
+   ((unsigned char *)dest)[0] = mx;
+   ((unsigned char *)dest)[1] = mn;
+   dest += 2;
+
+   // determine bias and emit color indices
+   dist = mx-mn;
+   bias = mn*7 - (dist >> 1);
+   dist4 = dist*4;
+   dist2 = dist*2;
+   bits = 0,mask=0;
+   
+   for (i=0;i<16;i++) {
+      int a = src[i*4+3]*7 - bias;
+      int ind,t;
+
+      // select index (hooray for bit magic)
+      t = (dist4 - a) >> 31;  ind =  t & 4; a -= dist4 & t;
+      t = (dist2 - a) >> 31;  ind += t & 2; a -= dist2 & t;
+      t = (dist - a) >> 31;   ind += t & 1;
+
+      ind = -ind & 7;
+      ind ^= (2 > ind);
+
+      // write index
+      mask |= ind << bits;
+      if((bits += 3) >= 8) {
+         *dest++ = mask;
+         mask >>= 8;
+         bits -= 8;
+      }
+   }
+}
+
+static void stb__InitDXT()
+{
+   int i;
+   for(i=0;i<32;i++)
+      stb__Expand5[i] = (i<<3)|(i>>2);
+
+   for(i=0;i<64;i++)
+      stb__Expand6[i] = (i<<2)|(i>>4);
+
+   for(i=0;i<256+16;i++)
+   {
+      int v = i-8 < 0 ? 0 : i-8 > 255 ? 255 : i-8;
+      stb__QuantRBTab[i] = stb__Expand5[stb__Mul8Bit(v,31)];
+      stb__QuantGTab[i] = stb__Expand6[stb__Mul8Bit(v,63)];
+   }
+
+   stb__PrepareOptTable(&stb__OMatch5[0][0],stb__Expand5,32);
+   stb__PrepareOptTable(&stb__OMatch6[0][0],stb__Expand6,64);
+}
+
+void stb_compress_dxt_block(unsigned char *dest, const unsigned char *src, int alpha, int quality)
+{
+   static int init=1;
+   if (init) {
+      stb__InitDXT();
+      init=0;
+   }
+
+   if (alpha) {
+      stb__CompressAlphaBlock(dest,(unsigned char*) src,quality);
+      dest += 8;
+   }
+
+   stb__CompressColorBlock(dest,(unsigned char*) src,quality);
+}
+#endif // STB_DEFINE
+
+#endif // STB_INCLUDE_STB_DXT_H