source: OniSplit/Imaging/Dxt1.cs@ 1131

using System;

namespace Oni.Imaging
{
        internal static class Dxt1
        {
                public static Surface Decompress(Surface src, SurfaceFormat dstFormat)
                {
            var dst = new Surface(src.Width, src.Height, dstFormat);
                        var colors = new Color[4];
                        int srcOffset = 0;

                        for (int y = 0; y < dst.Height; y += 4)
                        {
                                for (int x = 0; x < dst.Width; x += 4)
                                {
                                        colors[0] = Color.ReadBgr565(src.Data, srcOffset);
                                        srcOffset += 2;

                                        colors[1] = Color.ReadBgr565(src.Data, srcOffset);
                                        srcOffset += 2;

                                        if (colors[0].ToBgr565() > colors[1].ToBgr565())
                                        {
                                                colors[2] = Color.Lerp(colors[0], colors[1], 1.0f / 3.0f);
                                                colors[3] = Color.Lerp(colors[0], colors[1], 2.0f / 3.0f);
                                        }
                                        else
                                        {
                                                colors[2] = Color.Lerp(colors[0], colors[1], 0.5f);
                                                colors[3] = Color.Transparent;
                                        }

                                        for (int y2 = 0; y2 < 4; y2++)
                                        {
                                                int packedLookup = src.Data[srcOffset++];

                                                for (int x2 = 0; x2 < 4; x2++)
                                                {
                                                        dst[x + x2, y + y2] = colors[packedLookup & 3];
                                                        packedLookup >>= 2;
                                                }
                                        }
                                }
                        }

                        return dst;
                }

                public static Surface Compress(Surface src)
                {
                        var dst = new Surface(Utils.Align4(src.Width), Utils.Align4(src.Height), SurfaceFormat.DXT1);

                        var block = new Vector3[16];
                        var colors = new Vector3[4];
                        var lookup = new int[16];
                        int dstOffset = 0;
            int height = dst.Height;
            int width = dst.Width;

                        for (int y = 0; y < height; y += 4)
                        {
                                for (int x = 0; x < width; x += 4)
                                {
                                        for (int by = 0; by < 4; by++)
                                        {
                                                for (int bx = 0; bx < 4; bx++)
                                                        block[by * 4 + bx] = src[x + bx, y + by].ToVector3();
                                        }

                                        CompressBlock(block, lookup, colors);

                                        Color.WriteBgr565(new Color(colors[0]), dst.Data, dstOffset);
                                        dstOffset += 2;

                                        Color.WriteBgr565(new Color(colors[1]), dst.Data, dstOffset);
                                        dstOffset += 2;

                                        for (int by = 0; by < 4; by++)
                                        {
                                                int packedLookup = 0;

                                                for (int bx = 3; bx >= 0; bx--)
                                                        packedLookup = (packedLookup << 2) | lookup[by * 4 + bx];

                                                dst.Data[dstOffset++] = (byte)packedLookup;
                                        }
                                }
                        }

                        return dst;
                }

                private static void CompressBlock(Vector3[] block, int[] lookup, Vector3[] colors)
                {
                        colors[0] = block[0];
                        colors[1] = block[0];

                        for (int i = 1; i < block.Length; i++)
                        {
                                colors[0] = Vector3.Min(colors[0], block[i]);
                                colors[1] = Vector3.Max(colors[1], block[i]);
                        }

                        int maxColor;

                        if (new Color(colors[0]).ToBgr565() > new Color(colors[1]).ToBgr565())
                        {
                                colors[2] = Vector3.Lerp(colors[0], colors[1], 1.0f / 3.0f);
                                colors[3] = Vector3.Lerp(colors[0], colors[1], 2.0f / 3.0f);
                                maxColor = 4;
                        }
                        else
                        {
                                colors[2] = Vector3.Lerp(colors[0], colors[1], 0.5f);
                                maxColor = 3;
                        }

                        for (int i = 0; i < block.Length; i++)
                        {
                                lookup[i] = LookupNearest(colors, block[i], maxColor);
                        }
                }

                private static int LookupNearest(Vector3[] colors, Vector3 pixel, int maxColor)
                {
                        int index = 0;
                        float ds = Vector3.DistanceSquared(pixel, colors[0]);

                        for (int i = 1; i < maxColor; i++)
                        {
                                float newDs = Vector3.DistanceSquared(pixel, colors[i]);

                                if (newDs < ds)
                                {
                                        ds = newDs;
                                        index = i;
                                }
                        }

                        return index;
                }
        }
}