Merged mage-CompressedData into default

2026-08-16 00:02:12 +02:00 · 2013-04-09 23:44:00 -03:00
parent 9abfb9e23b 4cd14d5c08
commit c215541d6c
41 changed files with 2485 additions and 342 deletions
@@ -469,6 +469,7 @@ StringMap<Type, TYPE_MAX_ENUM>::Entry typeEntries[] =

 	// Image
 	{"ImageData", IMAGE_IMAGE_DATA_ID},
+	{"CompressedData", IMAGE_COMPRESSED_DATA_ID},

 	// Audio
 	{"Source", AUDIO_SOURCE_ID},
@@ -56,6 +56,7 @@ enum Type

 	// Image
 	IMAGE_IMAGE_DATA_ID,
+	IMAGE_COMPRESSED_DATA_ID,

 	// Audio
 	AUDIO_SOURCE_ID,
@@ -127,6 +128,7 @@ const bits GRAPHICS_SHADER_T = (bits(1) << GRAPHICS_SHADER_ID) | OBJECT_T;

 // Image.
 const bits IMAGE_IMAGE_DATA_T = (bits(1) << IMAGE_IMAGE_DATA_ID) | DATA_T;
+const bits IMAGE_COMPRESSED_DATA_T = (bits(1) << IMAGE_COMPRESSED_DATA_ID) | DATA_T;

 // Audio.
 const bits AUDIO_SOURCE_T = (bits(1) << AUDIO_SOURCE_ID) | OBJECT_T;
@@ -0,0 +1,235 @@
+/**
+ * Simple DDS data parser for compressed 2D textures.
+ *
+ * Copyright (c) 2013 Alexander Szpakowski.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ *
+ * Enums and structs copied from Microsoft.
+ * http://msdn.microsoft.com/en-us/library/bb943991.aspx
+ **/
+
+#ifndef DDS_INFO_H
+#define DDS_INFO_H
+
+#include <stdint.h>
+
+namespace dds
+{
+namespace dxinfo
+{
+
+enum DDPF
+{
+	DDPF_ALPHAPIXELS = 0x000001,
+	DDPF_ALPHA       = 0x000002,
+	DDPF_FOURCC      = 0x000004,
+	DDPF_RGB         = 0x000040,
+	DDPF_YUV         = 0x000200,
+	DDPF_LUMINANCE   = 0x020000
+};
+
+enum D3D10ResourceDimension
+{
+	D3D10_RESOURCE_DIMENSION_UNKNOWN   = 0,
+	D3D10_RESOURCE_DIMENSION_BUFFER    = 1,
+	D3D10_RESOURCE_DIMENSION_TEXTURE1D = 2,
+	D3D10_RESOURCE_DIMENSION_TEXTURE2D = 3,
+	D3D10_RESOURCE_DIMENSION_TEXTURE3D = 4
+};
+
+enum DXGIFormat
+{
+	DXGI_FORMAT_UNKNOWN                     = 0,
+
+	DXGI_FORMAT_R32G32B32A32_TYPELESS       = 1,
+	DXGI_FORMAT_R32G32B32A32_FLOAT          = 2,
+	DXGI_FORMAT_R32G32B32A32_UINT           = 3,
+	DXGI_FORMAT_R32G32B32A32_SINT           = 4,
+
+	DXGI_FORMAT_R32G32B32_TYPELESS          = 5,
+	DXGI_FORMAT_R32G32B32_FLOAT             = 6,
+	DXGI_FORMAT_R32G32B32_UINT              = 7,
+	DXGI_FORMAT_R32G32B32_SINT              = 8,
+
+	DXGI_FORMAT_R16G16B16A16_TYPELESS       = 9,
+	DXGI_FORMAT_R16G16B16A16_FLOAT          = 10,
+	DXGI_FORMAT_R16G16B16A16_UNORM          = 11,
+	DXGI_FORMAT_R16G16B16A16_UINT           = 12,
+	DXGI_FORMAT_R16G16B16A16_SNORM          = 13,
+	DXGI_FORMAT_R16G16B16A16_SINT           = 14,
+
+	DXGI_FORMAT_R32G32_TYPELESS             = 15,
+	DXGI_FORMAT_R32G32_FLOAT                = 16,
+	DXGI_FORMAT_R32G32_UINT                 = 17,
+	DXGI_FORMAT_R32G32_SINT                 = 18,
+
+	DXGI_FORMAT_R32G8X24_TYPELESS           = 19,
+	DXGI_FORMAT_D32_FLOAT_S8X24_UINT        = 20,
+	DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS    = 21,
+	DXGI_FORMAT_X32_TYPELESS_G8X24_UINT     = 22,
+
+	DXGI_FORMAT_R10G10B10A2_TYPELESS        = 23,
+	DXGI_FORMAT_R10G10B10A2_UNORM           = 24,
+	DXGI_FORMAT_R10G10B10A2_UINT            = 25,
+
+	DXGI_FORMAT_R11G11B10_FLOAT             = 26,
+
+	DXGI_FORMAT_R8G8B8A8_TYPELESS           = 27,
+	DXGI_FORMAT_R8G8B8A8_UNORM              = 28,
+	DXGI_FORMAT_R8G8B8A8_UNORM_SRGB         = 29,
+	DXGI_FORMAT_R8G8B8A8_UINT               = 30,
+	DXGI_FORMAT_R8G8B8A8_SNORM              = 31,
+	DXGI_FORMAT_R8G8B8A8_SINT               = 32,
+
+	DXGI_FORMAT_R16G16_TYPELESS             = 33,
+	DXGI_FORMAT_R16G16_FLOAT                = 34,
+	DXGI_FORMAT_R16G16_UNORM                = 35,
+	DXGI_FORMAT_R16G16_UINT                 = 36,
+	DXGI_FORMAT_R16G16_SNORM                = 37,
+	DXGI_FORMAT_R16G16_SINT                 = 38,
+
+	DXGI_FORMAT_R32_TYPELESS                = 39,
+	DXGI_FORMAT_D32_FLOAT                   = 40,
+	DXGI_FORMAT_R32_FLOAT                   = 41,
+	DXGI_FORMAT_R32_UINT                    = 42,
+	DXGI_FORMAT_R32_SINT                    = 43,
+
+	DXGI_FORMAT_R24G8_TYPELESS              = 44,
+	DXGI_FORMAT_D24_UNORM_S8_UINT           = 45,
+	DXGI_FORMAT_R24_UNORM_X8_TYPELESS       = 46,
+	DXGI_FORMAT_X24_TYPELESS_G8_UINT        = 47,
+
+	DXGI_FORMAT_R8G8_TYPELESS               = 48,
+	DXGI_FORMAT_R8G8_UNORM                  = 49,
+	DXGI_FORMAT_R8G8_UINT                   = 50,
+	DXGI_FORMAT_R8G8_SNORM                  = 51,
+	DXGI_FORMAT_R8G8_SINT                   = 52,
+
+	DXGI_FORMAT_R16_TYPELESS                = 53,
+	DXGI_FORMAT_R16_FLOAT                   = 54,
+	DXGI_FORMAT_D16_UNORM                   = 55,
+	DXGI_FORMAT_R16_UNORM                   = 56,
+	DXGI_FORMAT_R16_UINT                    = 57,
+	DXGI_FORMAT_R16_SNORM                   = 58,
+	DXGI_FORMAT_R16_SINT                    = 59,
+
+	DXGI_FORMAT_R8_TYPELESS                 = 60,
+	DXGI_FORMAT_R8_UNORM                    = 61,
+	DXGI_FORMAT_R8_UINT                     = 62,
+	DXGI_FORMAT_R8_SNORM                    = 63,
+	DXGI_FORMAT_R8_SINT                     = 64,
+	DXGI_FORMAT_A8_UNORM                    = 65,
+
+	DXGI_FORMAT_R1_UNORM                    = 66,
+
+	DXGI_FORMAT_R9G9B9E5_SHAREDEXP          = 67,
+
+	DXGI_FORMAT_R8G8_B8G8_UNORM             = 68,
+	DXGI_FORMAT_G8R8_G8B8_UNORM             = 69,
+
+	DXGI_FORMAT_BC1_TYPELESS                = 70,
+	DXGI_FORMAT_BC1_UNORM                   = 71,
+	DXGI_FORMAT_BC1_UNORM_SRGB              = 72,
+
+	DXGI_FORMAT_BC2_TYPELESS                = 73,
+	DXGI_FORMAT_BC2_UNORM                   = 74,
+	DXGI_FORMAT_BC2_UNORM_SRGB              = 75,
+
+	DXGI_FORMAT_BC3_TYPELESS                = 76,
+	DXGI_FORMAT_BC3_UNORM                   = 77,
+	DXGI_FORMAT_BC3_UNORM_SRGB              = 78,
+
+	DXGI_FORMAT_BC4_TYPELESS                = 79,
+	DXGI_FORMAT_BC4_UNORM                   = 80,
+	DXGI_FORMAT_BC4_SNORM                   = 81,
+
+	DXGI_FORMAT_BC5_TYPELESS                = 82,
+	DXGI_FORMAT_BC5_UNORM                   = 83,
+	DXGI_FORMAT_BC5_SNORM                   = 84,
+
+	DXGI_FORMAT_B5G6R5_UNORM                = 85,
+	DXGI_FORMAT_B5G5R5A1_UNORM              = 86,
+	DXGI_FORMAT_B8G8R8A8_UNORM              = 87,
+	DXGI_FORMAT_B8G8R8X8_UNORM              = 88,
+
+	DXGI_FORMAT_R10G10B10_XR_BIAS_A2_UNORM  = 89,
+	DXGI_FORMAT_B8G8R8A8_TYPELESS           = 90,
+	DXGI_FORMAT_B8G8R8A8_UNORM_SRGB         = 91,
+	DXGI_FORMAT_B8G8R8X8_TYPELESS           = 92,
+	DXGI_FORMAT_B8G8R8X8_UNORM_SRGB         = 93,
+
+	DXGI_FORMAT_BC6H_TYPELESS               = 94,
+	DXGI_FORMAT_BC6H_UF16                   = 95,
+	DXGI_FORMAT_BC6H_SF16                   = 96,
+
+	DXGI_FORMAT_BC7_TYPELESS                = 97,
+	DXGI_FORMAT_BC7_UNORM                   = 98,
+	DXGI_FORMAT_BC7_UNORM_SRGB              = 99,
+
+	DXGI_FORMAT_FORCE_UINT                  = 0xffffffffUL
+};
+
+struct DDSPixelFormat
+{
+	uint32_t size;
+	uint32_t flags;
+	uint32_t fourCC;
+	uint32_t rgbBitCount;
+	uint32_t rBitMask;
+	uint32_t gBitMask;
+	uint32_t bBitMask;
+	uint32_t aBitMask;
+};
+
+struct DDSHeader
+{
+	uint32_t size;
+	uint32_t flags;
+	uint32_t height;
+	uint32_t width;
+	uint32_t pitchOrLinearSize;
+	uint32_t depth;
+	uint32_t mipMapCount;
+	uint32_t reserved[11];
+
+	DDSPixelFormat format;
+
+	uint32_t caps1;
+	uint32_t caps2;
+	uint32_t caps3;
+	uint32_t caps4;
+	uint32_t reserved2;
+};
+
+struct DDSHeader10
+{
+	DXGIFormat dxgiFormat;
+	D3D10ResourceDimension resourceDimension;
+
+	uint32_t miscFlag;
+	uint32_t arraySize;
+	uint32_t reserved;
+};
+
+} // dxinfo
+} // dds
+
+#endif // DDS_INFO_H
@@ -0,0 +1,358 @@
+/**
+ * Simple DDS data parser for compressed 2D textures.
+ *
+ * Copyright (c) 2013 Alexander Szpakowski.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ **/
+
+#include "ddsparse.h"
+#include "ddsinfo.h"
+
+#include <algorithm>
+
+namespace dds
+{
+
+using namespace dds::dxinfo;
+
+// Creates a packed uint representation of a FourCC code.
+static inline uint32_t FourCC(char a, char b, char c, char d)
+{
+	uint32_t fcc = ((uint32_t) a)
+	            | (((uint32_t) b) << 8)
+	            | (((uint32_t) c) << 16)
+	            | (((uint32_t) d) << 24);
+
+	return fcc;
+}
+
+Parser::Image::Image()
+	: width(0)
+	, height(0)
+	, dataSize(0)
+	, data(0)
+{
+}
+
+bool Parser::isDDS(const void *data, size_t dataSize)
+{
+	const uint8_t *readData = (const uint8_t *) data;
+	ptrdiff_t offset = 0;
+
+	// Is the data large enough to hold the DDS header?
+	if(dataSize < sizeof(uint32_t) + sizeof(DDSHeader))
+		return false;
+
+	// All DDS files start with "DDS ".
+	if((*(uint32_t *) readData) != FourCC('D','D','S',' '))
+		return false;
+
+	offset += sizeof(uint32_t);
+
+	DDSHeader *header = (DDSHeader *) &readData[offset];
+
+
+	// Verify header to validate DDS data.
+	if (header->size != sizeof(DDSHeader) || header->format.size != sizeof(DDSPixelFormat))
+		return false;
+
+	offset += sizeof(DDSHeader);
+
+	// Check for DX10 extension.
+	if ((header->format.flags & DDPF_FOURCC) && (header->format.fourCC == FourCC('D','X','1','0')))
+	{
+		// Data must be big enough for both headers plus the magic value.
+		if (dataSize < (sizeof(uint32_t) + sizeof(DDSHeader) + sizeof(DDSHeader10)))
+			return false;
+	}
+
+	return true;
+}
+
+bool Parser::isCompressedDDS(const void *data, size_t dataSize)
+{
+	if (!isDDS(data, dataSize))
+		return false;
+
+	const uint8_t *readData = (const uint8_t *) data;
+	ptrdiff_t offset = sizeof(uint32_t);
+
+	DDSHeader *header = (DDSHeader *) &readData[offset];
+	offset += sizeof(DDSHeader);
+
+	// Check for DX10 extension.
+	if ((header->format.flags & DDPF_FOURCC) && (header->format.fourCC == FourCC('D','X','1','0')))
+	{
+		DDSHeader10 *header10 = (DDSHeader10 *) &readData[offset];
+		return parseDX10Format(header10->dxgiFormat) != FORMAT_UNKNOWN;
+	}
+
+	return parseDDSFormat(header->format) != FORMAT_UNKNOWN;
+}
+
+Parser::Parser(const void *data, size_t dataSize)
+	: format(FORMAT_UNKNOWN)
+{
+	parseData(data, dataSize);
+}
+
+Parser::Parser(const Parser &other)
+	: texData(other.texData)
+	, format(other.format)
+{
+}
+
+Parser::Parser()
+	: format(FORMAT_UNKNOWN)
+{
+}
+
+Parser &Parser::operator = (const Parser &other)
+{
+	texData = other.texData;
+	format = other.format;
+
+	return *this;
+}
+
+Parser::~Parser()
+{
+}
+
+Format Parser::getFormat() const
+{
+	return format;
+}
+
+const Parser::Image *Parser::getImageData(size_t miplevel) const
+{
+	if (miplevel >= texData.size())
+		return 0;
+
+	return &texData[miplevel];
+}
+
+size_t Parser::getNumMipmaps() const
+{
+	return texData.size();
+}
+
+Format Parser::parseDDSFormat(const DDSPixelFormat &fmt)
+{
+	if (fmt.flags & DDPF_FOURCC)
+	{
+		if (fmt.fourCC == FourCC('D','X','T','1'))
+			return FORMAT_DXT1;
+		else if (fmt.fourCC == FourCC('D','X','T','3'))
+			return FORMAT_DXT3;
+		else if (fmt.fourCC == FourCC('D','X','T','5'))
+			return FORMAT_DXT5;
+		else if (fmt.fourCC == FourCC('A','T','I','1'))
+			return FORMAT_BC4;
+		else if (fmt.fourCC == FourCC('A','T','I','2'))
+			return FORMAT_BC5;
+		else if (fmt.fourCC == FourCC('B','C','4','U'))
+			return FORMAT_BC4;
+		else if (fmt.fourCC == FourCC('B','C','4','S'))
+			return FORMAT_BC4s;
+		else if (fmt.fourCC == FourCC('B','C','5','U'))
+			return FORMAT_BC5;
+		else if (fmt.fourCC == FourCC('B','C','5','S'))
+			return FORMAT_BC5s;
+	}
+
+	return FORMAT_UNKNOWN;
+}
+
+Format Parser::parseDX10Format(DXGIFormat fmt)
+{
+	Format f = FORMAT_UNKNOWN;
+
+	switch (fmt)
+	{
+	case DXGI_FORMAT_BC1_TYPELESS:
+	case DXGI_FORMAT_BC1_UNORM:
+	case DXGI_FORMAT_BC1_UNORM_SRGB:
+		f = FORMAT_DXT1;
+		break;
+	case DXGI_FORMAT_BC2_TYPELESS:
+	case DXGI_FORMAT_BC2_UNORM:
+	case DXGI_FORMAT_BC2_UNORM_SRGB:
+		f = FORMAT_DXT3;
+		break;
+	case DXGI_FORMAT_BC3_TYPELESS:
+	case DXGI_FORMAT_BC3_UNORM:
+	case DXGI_FORMAT_BC3_UNORM_SRGB:
+		f = FORMAT_DXT5;
+		break;
+	case DXGI_FORMAT_BC4_TYPELESS:
+	case DXGI_FORMAT_BC4_UNORM:
+		f = FORMAT_BC4;
+		break;
+	case DXGI_FORMAT_BC4_SNORM:
+		f = FORMAT_BC4s;
+		break;
+	case DXGI_FORMAT_BC5_TYPELESS:
+	case DXGI_FORMAT_BC5_UNORM:
+		f = FORMAT_BC5;
+		break;
+	case DXGI_FORMAT_BC5_SNORM:
+		f = FORMAT_BC5s;
+		break;
+	case DXGI_FORMAT_BC6H_TYPELESS:
+	case DXGI_FORMAT_BC6H_UF16:
+		f = FORMAT_BC6H;
+		break;
+	case DXGI_FORMAT_BC6H_SF16:
+		f = FORAMT_BC6Hs;
+		break;
+	case DXGI_FORMAT_BC7_TYPELESS:
+	case DXGI_FORMAT_BC7_UNORM:
+		f = FORMAT_BC7;
+		break;
+	case DXGI_FORMAT_BC7_UNORM_SRGB:
+		f = FORMAT_BC7srgb;
+		break;
+	default:
+		break;
+	}
+
+	return f;
+}
+
+size_t Parser::parseImageSize(Format fmt, int width, int height) const
+{
+	size_t size = 0;
+
+	switch (fmt)
+	{
+	case FORMAT_DXT1:
+	case FORMAT_DXT3:
+	case FORMAT_DXT5:
+	case FORMAT_BC5s:
+	case FORMAT_BC5:
+	case FORMAT_BC7:
+	case FORMAT_BC7srgb:
+		{
+			int numBlocksWide = 0;
+			if (width > 0)
+				numBlocksWide = std::max(1, (width + 3) / 4);
+
+			int numBlocksHigh = 0;
+			if (height > 0)
+				numBlocksHigh = std::max(1, (height + 3) / 4);
+
+			int numBytesPerBlock = (fmt == FORMAT_DXT1 ? 8 : 16);
+
+			size = numBlocksWide * numBytesPerBlock * numBlocksHigh;
+		}
+		break;
+	default:
+		break;
+	}
+
+	return size;
+}
+
+bool Parser::parseTexData(const uint8_t *data, size_t dataSize, Format fmt, int w, int h, int mips)
+{
+	size_t offset = 0;
+	std::vector<Image> newTexData;
+
+	for (int i = 0; i < mips; i++)
+	{
+		Image img;
+		img.width = w;
+		img.height = h;
+
+		img.dataSize = parseImageSize(fmt, img.width, img.height);
+
+		// Make sure the data size is valid.
+		if (img.dataSize == 0 || (offset + img.dataSize) > dataSize)
+			return false;
+
+		// Store the memory address of the data representing this mip level.
+		img.data = &data[offset];
+
+		newTexData.push_back(img);
+
+		// Move to the next mip level.
+		offset += img.dataSize;
+
+		w = std::max(w / 2, 1);
+		h = std::max(h / 2, 1);
+	}
+
+	texData = newTexData;
+
+	return true;
+}
+
+bool Parser::parseData(const void *data, size_t dataSize)
+{
+	if (!isDDS(data, dataSize))
+		return false;
+
+	const uint8_t *readData = (const uint8_t *) data;
+	ptrdiff_t offset = sizeof(uint32_t);
+
+	DDSHeader *header = (DDSHeader *) &readData[offset];
+	offset += sizeof(DDSHeader);
+
+
+	// Check for DX10 extension.
+	if ((header->format.flags & DDPF_FOURCC) && (header->format.fourCC == FourCC('D','X','1','0')))
+	{
+		DDSHeader10 *header10 = (DDSHeader10 *) &readData[offset];
+		offset += sizeof(DDSHeader10);
+
+		// We can't deal with 1D/3D textures.
+		switch (header10->resourceDimension)
+		{
+		case D3D10_RESOURCE_DIMENSION_TEXTURE2D:
+		case D3D10_RESOURCE_DIMENSION_UNKNOWN:
+			break;
+		default:
+			return false;
+		}
+
+		// We also can't deal with texture arrays and cubemaps.
+		if (header10->arraySize > 1)
+			return false;
+
+		format = parseDX10Format(header10->dxgiFormat);
+	}
+	else
+		format = parseDDSFormat(header->format);
+
+
+	if (format == FORMAT_UNKNOWN)
+		return false;
+
+
+	int w = header->width;
+	int h = header->height;
+
+	int mips = std::max((int) header->mipMapCount, 1);
+
+	return parseTexData(&readData[offset], dataSize - offset, format, w, h, mips);
+}
+
+} // dds
@@ -0,0 +1,144 @@
+/**
+ * Simple DDS data parser for compressed 2D textures.
+ *
+ * Copyright (c) 2013 Alexander Szpakowski.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ **/
+
+#ifndef DDS_PARSE_H
+#define DDS_PARSE_H
+
+#include "ddsinfo.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <vector>
+#include <exception>
+
+namespace dds
+{
+
+// Supported DDS formats.
+// Formats with an 's' suffix have signed data.
+enum Format
+{
+	FORMAT_DXT1,
+	FORMAT_DXT3,
+	FORMAT_DXT5,
+	FORMAT_BC4,
+	FORMAT_BC4s,
+	FORMAT_BC5,
+	FORMAT_BC5s,
+	FORMAT_BC6H,
+	FORAMT_BC6Hs,
+	FORMAT_BC7,
+	FORMAT_BC7srgb, // sRGB color space.
+	FORMAT_UNKNOWN
+};
+
+class Parser
+{
+public:
+
+	// Represents a single mipmap level of a texture.
+	struct Image
+	{
+		int width;
+		int height;
+		size_t dataSize;
+		const uint8_t *data;
+
+		Image();
+	};
+
+	/**
+	 * Determines whether the input byte data represents a valid DDS file.
+	 * Does not take into account whether the texture format is supported.
+	 *
+	 * @param data     The byte data to parse.
+	 * @param dataSize The size in bytes of the data.
+	 **/
+	static bool isDDS(const void *data, size_t dataSize);
+
+	/**
+	 * Determines whether the input byte data represents a valid compressed DDS
+	 * file. Takes into account texture format, but not type (3D textures, etc.)
+	 *
+	 * @param data     The byte data to parse.
+	 * @param dataSize The size in bytes of the data.
+	 **/
+	static bool isCompressedDDS(const void *data, size_t dataSize);
+
+	/**
+	 * Constructor.
+	 * Attempts to parse byte data as a compressed DDS file.
+	 *
+	 * @param data     The byte data to parse.
+	 * @param dataSize The size in bytes of the data.
+	 **/
+	Parser(const void *data, size_t dataSize);
+	Parser(const Parser &other);
+	Parser();
+
+	Parser &operator = (const Parser &other);
+
+	~Parser();
+
+	/**
+	 * Gets the format of this texture.
+	 **/
+	Format getFormat() const;
+
+	/**
+	 * Gets the data of this texture at a mipmap level. Mipmap level 0
+	 * represents the base image.
+	 *
+	 * @param miplevel The mipmap level to get the data of.
+	 * @return Pointer to the image data, or NULL if miplevel is not within the
+	 *         range of [0, numMipmaps).
+	 **/
+	const Image *getImageData(size_t miplevel = 0) const;
+
+	/**
+	 * Gets the number of mipmap levels in this texture.
+	 * Includes the base mip level.
+	 **/
+	size_t getNumMipmaps() const;
+
+private:
+
+	static Format parseDDSFormat(const dxinfo::DDSPixelFormat &fmt);
+	static Format parseDX10Format(dxinfo::DXGIFormat fmt);
+
+	size_t parseImageSize(Format fmt, int width, int height) const;
+
+	bool parseTexData(const uint8_t *data, size_t dataSize, Format fmt, int w, int h, int mips);
+
+	bool parseData(const void *data, size_t dataSize);
+
+	std::vector<Image> texData;
+	Format format;
+
+}; // Parser
+
+} // dds
+
+#endif // DDS_PARSE_H
@@ -52,7 +52,7 @@ static const luaL_Reg w_FileData_functions[] =
 {

 	// Data
-	{ "getPointer", w_Data_getPointer },
+//	{ "getPointer", w_Data_getPointer },
 	{ "getSize", w_Data_getSize },

 	{ "getFilename", w_FileData_getFilename },
@@ -105,14 +105,36 @@ int w_newFile(lua_State *L)

 int w_newFileData(lua_State *L)
 {
-	if (!lua_isstring(L, 1))
-		return luaL_error(L, "String expected.");
-	if (!lua_isstring(L, 2))
-		return luaL_error(L, "String expected.");
+	// Single argument: treat as filepath or File.
+	if (lua_gettop(L) == 1)
+	{
+		if (lua_isstring(L, 1))
+			luax_convobj(L, 1, "filesystem", "newFile");
+
+		// Get FileData from the File.
+		if (luax_istype(L, 1, FILESYSTEM_FILE_T))
+		{
+			File *file = luax_checktype<File>(L, 1, "File", FILESYSTEM_FILE_T);
+
+			FileData *data = 0;
+			try
+			{
+				data = file->read();
+			}
+			catch (love::Exception &e)
+			{
+				return luaL_error(L, "%s", e.what());
+			}
+			luax_newtype(L, "FileData", FILESYSTEM_FILE_DATA_T, (void *) data);
+			return 1;
+		}
+		else
+			return luaL_argerror(L, 1, "string or File expected");
+	}

 	size_t length = 0;
-	const char *str = lua_tolstring(L, 1, &length);
-	const char *filename = lua_tostring(L, 2);
+	const char *str = luaL_checklstring(L, 1, &length);
+	const char *filename = luaL_checkstring(L, 2);
 	const char *decstr = lua_isstring(L, 3) ? lua_tostring(L, 3) : 0;

 	FileData::Decoder decoder = FileData::FILE;
@@ -32,7 +32,7 @@ GlyphData *luax_checkglyphdata(lua_State *L, int idx)

 static const luaL_Reg functions[] =
 {
-	{ "getPointer", w_Data_getPointer },
+//	{ "getPointer", w_Data_getPointer },
 	{ "getSize", w_Data_getSize },
 	{ 0, 0 }
 };
@@ -163,6 +163,9 @@ StringMap<Graphics::Support, Graphics::SUPPORT_MAX_ENUM>::Entry Graphics::suppor
 	{ "npot", Graphics::SUPPORT_NPOT },
 	{ "subtractive", Graphics::SUPPORT_SUBTRACTIVE },
 	{ "mipmap", Graphics::SUPPORT_MIPMAP },
+	{ "dxt", Graphics::SUPPORT_DXT },
+	{ "bc5", Graphics::SUPPORT_BC5 },
+	{ "bc7", Graphics::SUPPORT_BC7 },
 };

 StringMap<Graphics::Support, Graphics::SUPPORT_MAX_ENUM> Graphics::support(Graphics::supportEntries, sizeof(Graphics::supportEntries));
@@ -92,6 +92,9 @@ public:
 		SUPPORT_NPOT,
 		SUPPORT_SUBTRACTIVE,
 		SUPPORT_MIPMAP,
+		SUPPORT_DXT,
+		SUPPORT_BC5,
+		SUPPORT_BC7,
 		SUPPORT_MAX_ENUM
 	};

@@ -225,6 +225,9 @@ void Graphics::present()

 void Graphics::setIcon(Image *image)
 {
+	if (image->isCompressed())
+		throw love::Exception("Cannot use compressed image data to set an icon.");
+
 	currentWindow->setIcon(image->getData());
 }

@@ -331,9 +334,11 @@ int Graphics::getScissor(lua_State *L) const

 void Graphics::defineStencil()
 {
+	// Disable color writes but don't save the mask values.
 	glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
-	glEnable(GL_STENCIL_TEST);
+
 	glClear(GL_STENCIL_BUFFER_BIT);
+	glEnable(GL_STENCIL_TEST);
 	glStencilFunc(GL_ALWAYS, 1, 1);
 	glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
 }
@@ -374,6 +379,29 @@ Image *Graphics::newImage(love::image::ImageData *data)
 	return image;
 }

+Image *Graphics::newImage(love::image::CompressedData *cdata)
+{
+	// Create the image.
+	Image *image = new Image(cdata);
+	bool success;
+	try
+	{
+		success = image->load();
+	}
+	catch(love::Exception &)
+	{
+		image->release();
+		throw;
+	}
+	if (!success)
+	{
+		image->release();
+		return 0;
+	}
+
+	return image;
+}
+
 Quad *Graphics::newQuad(float x, float y, float w, float h, float sw, float sh)
 {
 	Quad::Viewport v;
@@ -251,8 +251,8 @@ public:
 	/**
 	 * Creates an Image object with padding and/or optimization.
 	 **/
-	Image *newImage(love::filesystem::File *file);
 	Image *newImage(love::image::ImageData *data);
+	Image *newImage(love::image::CompressedData *cdata);

 	/**
 	 * Creates a Quad object.
@@ -24,8 +24,6 @@
 #include <cstring> // For memcpy
 #include <algorithm> // for min/max

-#include <iostream>
-
 namespace love
 {
 namespace graphics
@@ -39,43 +37,39 @@ Image::FilterMode Image::defaultMipmapFilter = Image::FILTER_NONE;
 float Image::defaultMipmapSharpness = 0.0f;

 Image::Image(love::image::ImageData *data)
-	: width((float)(data->getWidth()))
+	: cdata(0)
+	, width((float)(data->getWidth()))
 	, height((float)(data->getHeight()))
 	, texture(0)
 	, mipmapSharpness(defaultMipmapSharpness)
 	, mipmapsCreated(false)
+	, compressed(false)
 {
 	data->retain();
 	this->data = data;
+	preload();
+}

-	memset(vertices, 255, sizeof(vertex)*4);
-
-	vertices[0].x = 0;
-	vertices[0].y = 0;
-	vertices[1].x = 0;
-	vertices[1].y = height;
-	vertices[2].x = width;
-	vertices[2].y = height;
-	vertices[3].x = width;
-	vertices[3].y = 0;
-
-	vertices[0].s = 0;
-	vertices[0].t = 0;
-	vertices[1].s = 0;
-	vertices[1].t = 1;
-	vertices[2].s = 1;
-	vertices[2].t = 1;
-	vertices[3].s = 1;
-	vertices[3].t = 0;
-
-	filter = getDefaultFilter();
-	filter.mipmap = defaultMipmapFilter;
+Image::Image(love::image::CompressedData *cdata)
+	: data(0)
+	, width((float)(cdata->getWidth(0)))
+	, height((float)(cdata->getHeight(0)))
+	, texture(0)
+	, mipmapSharpness(defaultMipmapSharpness)
+	, mipmapsCreated(false)
+	, compressed(true)
+{
+	cdata->retain();
+	this->cdata = cdata;
+	preload();
 }

 Image::~Image()
 {
 	if (data != 0)
 		data->release();
+	if (cdata != 0)
+		cdata->release();
 	unload();
 }

@@ -99,40 +93,6 @@ love::image::ImageData *Image::getData() const
 	return data;
 }

-void Image::getRectangleVertices(int x, int y, int w, int h, vertex *vertices) const
-{
-	// Check upper.
-	x = (x+w > (int)width) ? (int)width-w : x;
-	y = (y+h > (int)height) ? (int)height-h : y;
-
-	// Check lower.
-	x = (x < 0) ? 0 : x;
-	y = (y < 0) ? 0 : y;
-
-	vertices[0].x = 0;
-	vertices[0].y = 0;
-	vertices[1].x = 0;
-	vertices[1].y = (float)h;
-	vertices[2].x = (float)w;
-	vertices[2].y = (float)h;
-	vertices[3].x = (float)w;
-	vertices[3].y = 0;
-
-	float tx = (float)x/width;
-	float ty = (float)y/height;
-	float tw = (float)w/width;
-	float th = (float)h/height;
-
-	vertices[0].s = tx;
-	vertices[0].t = ty;
-	vertices[1].s = tx;
-	vertices[1].t = ty+th;
-	vertices[2].s = tx+tw;
-	vertices[2].t = ty+th;
-	vertices[3].s = tx+tw;
-	vertices[3].t = ty;
-}
-
 void Image::draw(float x, float y, float angle, float sx, float sy, float ox, float oy, float kx, float ky) const
 {
 	static Matrix t;
@@ -150,19 +110,57 @@ void Image::drawq(love::graphics::Quad *quad, float x, float y, float angle, flo
 	drawv(t, v);
 }

-void Image::checkMipmapsCreated()
+void Image::uploadCompressedMipmaps()
 {
-	if (mipmapsCreated || (filter.mipmap != FILTER_NEAREST && filter.mipmap != FILTER_LINEAR))
+	if (!isCompressed() || !cdata || !hasCompressedTextureSupport(cdata->getType()))
+		return;
+
+	bind();
+
+	int numMipmaps = cdata->getNumMipmaps();
+
+	// We have to inform OpenGL if the image doesn't have all mipmap levels.
+	if (GLEE_VERSION_1_2 || GLEE_SGIS_texture_lod)
+	{
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, numMipmaps - 1);
+	}
+	else if (cdata->getWidth(numMipmaps-1) > 1 || cdata->getHeight(numMipmaps-1) > 1)
+	{
+		// Telling OpenGL to ignore certain levels isn't always supported.
+		throw love::Exception("Cannot load mipmaps: "
+		      "compressed image does not have all required levels.");
+	}
+
+	for (int i = 1; i < numMipmaps; i++)
+	{
+		glCompressedTexImage2DARB(GL_TEXTURE_2D,
+		                          i,
+		                          getCompressedFormat(cdata->getType()),
+		                          cdata->getWidth(i),
+		                          cdata->getHeight(i),
+		                          0,
+		                          GLsizei(cdata->getSize(i)),
+		                          cdata->getData(i));
+	}
+}
+
+void Image::createMipmaps()
+{
+	if (!data)
 		return;

 	if (!hasMipmapSupport())
 		throw love::Exception("Mipmap filtering is not supported on this system.");

-	// Some old drivers claim support for NPOT textures, but fail when creating mipmaps.
-	// we can't detect which systems will do this, so we fail gracefully for all NPOT images.
+	// Some old drivers claim support for NPOT textures, but fail when creating
+	// mipmaps. We can't detect which systems will do this, so we fail gracefully
+	// for all NPOT images.
 	int w = int(width), h = int(height);
 	if (w != next_p2(w) || h != next_p2(h))
-		throw love::Exception("Cannot create mipmaps: image does not have power of two dimensions.");
+	{
+		throw love::Exception("Cannot create mipmaps: "
+		      "image does not have power of two dimensions.");
+	}

 	bind();

@@ -171,14 +169,14 @@ void Image::checkMipmapsCreated()
 		// AMD/ATI drivers have several bugs when generating mipmaps,
 		// re-uploading the entire base image seems to be required.
 		glTexImage2D(GL_TEXTURE_2D,
-		             0,
-		             GL_RGBA8,
-		             (GLsizei)width,
-		             (GLsizei)height,
-		             0,
-		             GL_RGBA,
-		             GL_UNSIGNED_BYTE,
-		             data->getData());
+					 0,
+					 GL_RGBA8,
+					 (GLsizei)width,
+					 (GLsizei)height,
+					 0,
+					 GL_RGBA,
+					 GL_UNSIGNED_BYTE,
+					 data->getData());

 		// More bugs: http://www.opengl.org/wiki/Common_Mistakes#Automatic_mipmap_generation
 		glEnable(GL_TEXTURE_2D);
@@ -188,15 +186,28 @@ void Image::checkMipmapsCreated()
 	{
 		glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
 		glTexSubImage2D(GL_TEXTURE_2D,
-		                0,
-		                0,
-		                0,
-		                (GLsizei)width,
-		                (GLsizei)height,
-		                GL_RGBA,
-		                GL_UNSIGNED_BYTE,
-		                data->getData());
+						0,
+						0,
+						0,
+						(GLsizei)width,
+						(GLsizei)height,
+						GL_RGBA,
+						GL_UNSIGNED_BYTE,
+						data->getData());
 	}
+}
+
+void Image::checkMipmapsCreated()
+{
+	if (mipmapsCreated || filter.mipmap == FILTER_NONE)
+		return;
+
+	if (isCompressed() && cdata && hasCompressedTextureSupport(cdata->getType()))
+		uploadCompressedMipmaps();
+	else if (data)
+		createMipmaps();
+	else
+		return;

 	mipmapsCreated = true;
 }
@@ -236,7 +247,9 @@ void Image::setMipmapSharpness(float sharpness)
 		mipmapSharpness = std::min(std::max(sharpness, -maxMipmapSharpness + 0.01f), maxMipmapSharpness - 0.01f);

 		bind();
-		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -mipmapSharpness); // negative bias is sharper
+
+		// negative bias is sharper
+		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_LOD_BIAS, -mipmapSharpness);
 	}
 	else
 		mipmapSharpness = 0.0f;
@@ -255,6 +268,32 @@ void Image::bind() const
 	bindTexture(texture);
 }

+void Image::preload()
+{
+	memset(vertices, 255, sizeof(vertex)*4);
+
+	vertices[0].x = 0;
+	vertices[0].y = 0;
+	vertices[1].x = 0;
+	vertices[1].y = height;
+	vertices[2].x = width;
+	vertices[2].y = height;
+	vertices[3].x = width;
+	vertices[3].y = 0;
+
+	vertices[0].s = 0;
+	vertices[0].t = 0;
+	vertices[1].s = 0;
+	vertices[1].t = 1;
+	vertices[2].s = 1;
+	vertices[2].t = 1;
+	vertices[3].s = 1;
+	vertices[3].t = 0;
+
+	filter = getDefaultFilter();
+	filter.mipmap = defaultMipmapFilter;
+}
+
 bool Image::load()
 {
 	return loadVolatile();
@@ -267,6 +306,18 @@ void Image::unload()

 bool Image::loadVolatile()
 {
+	if (isCompressed() && cdata && !hasCompressedTextureSupport(cdata->getType()))
+	{
+		const char *str;
+		if (image::CompressedData::getConstant(cdata->getType(), str))
+		{
+			throw love::Exception("Cannot create image: "
+			      "%s compressed images are not supported on this system.", str);
+		}
+		else
+			throw love::Exception("cannot create image: format is not supported on this system.");
+	}
+
 	if (hasMipmapSharpnessSupport() && maxMipmapSharpness == 0.0f)
 		glGetFloatv(GL_MAX_TEXTURE_LOD_BIAS, &maxMipmapSharpness);

@@ -296,25 +347,45 @@ bool Image::loadVolatilePOT()

 	while (glGetError() != GL_NO_ERROR); // clear errors

-	glTexImage2D(GL_TEXTURE_2D,
-	             0,
-	             GL_RGBA8,
-	             (GLsizei)p2width,
-	             (GLsizei)p2height,
-	             0,
-	             GL_RGBA,
-	             GL_UNSIGNED_BYTE,
-	             0);
+	if (isCompressed() && cdata)
+	{
+		if (s < 1.0f || t < 1.0f)
+		{
+			throw love::Exception("Cannot create image: "
+				  "compressed NPOT images are not supported on this system.");
+		}

-	glTexSubImage2D(GL_TEXTURE_2D,
-	                0,
-	                0,
-	                0,
-	                (GLsizei)width,
-	                (GLsizei)height,
-	                GL_RGBA,
-	                GL_UNSIGNED_BYTE,
-	                data->getData());
+		glCompressedTexImage2DARB(GL_TEXTURE_2D,
+		                          0,
+		                          getCompressedFormat(cdata->getType()),
+		                          cdata->getWidth(0),
+		                          cdata->getHeight(0),
+		                          0,
+		                          GLsizei(cdata->getSize(0)),
+		                          cdata->getData(0));
+	}
+	else if (data)
+	{
+		glTexImage2D(GL_TEXTURE_2D,
+		             0,
+		             GL_RGBA8,
+		             (GLsizei)p2width,
+		             (GLsizei)p2height,
+		             0,
+		             GL_RGBA,
+		             GL_UNSIGNED_BYTE,
+		             0);
+
+		glTexSubImage2D(GL_TEXTURE_2D,
+		                0,
+		                0,
+		                0,
+		                (GLsizei)width,
+		                (GLsizei)height,
+		                GL_RGBA,
+		                GL_UNSIGNED_BYTE,
+		                data->getData());
+	}

 	if (glGetError() != GL_NO_ERROR)
 		throw love::Exception("Cannot create image: size may be too large for this system.");
@@ -337,15 +408,30 @@ bool Image::loadVolatileNPOT()

 	while (glGetError() != GL_NO_ERROR); // clear errors

-	glTexImage2D(GL_TEXTURE_2D,
-	             0,
-	             GL_RGBA8,
-	             (GLsizei)width,
-	             (GLsizei)height,
-	             0,
-	             GL_RGBA,
-	             GL_UNSIGNED_BYTE,
-	             data->getData());
+	if (isCompressed() && cdata)
+	{
+		GLenum format = getCompressedFormat(cdata->getType());
+		glCompressedTexImage2DARB(GL_TEXTURE_2D,
+		                          0,
+		                          format,
+		                          cdata->getWidth(0),
+		                          cdata->getHeight(0),
+		                          0,
+		                          GLsizei(cdata->getSize(0)),
+		                          cdata->getData(0));
+	}
+	else if (data)
+	{
+		glTexImage2D(GL_TEXTURE_2D,
+		             0,
+		             GL_RGBA8,
+		             (GLsizei)width,
+		             (GLsizei)height,
+		             0,
+		             GL_RGBA,
+		             GL_UNSIGNED_BYTE,
+		             data->getData());
+	}

 	if (glGetError() != GL_NO_ERROR)
 		throw love::Exception("Cannot create image: size may be too large for this system.");
@@ -407,6 +493,34 @@ Image::FilterMode Image::getDefaultMipmapFilter()
 	return defaultMipmapFilter;
 }

+bool Image::isCompressed() const
+{
+	return compressed;
+}
+
+GLenum Image::getCompressedFormat(image::CompressedData::TextureType type) const
+{
+	switch (type)
+	{
+	case image::CompressedData::TYPE_DXT1:
+		return GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+	case image::CompressedData::TYPE_DXT3:
+		return GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+	case image::CompressedData::TYPE_DXT5:
+		return GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+	case image::CompressedData::TYPE_BC5:
+		return GL_COMPRESSED_RG_RGTC2;
+	case image::CompressedData::TYPE_BC5s:
+		return GL_COMPRESSED_SIGNED_RG_RGTC2;
+	case image::CompressedData::TYPE_BC7:
+		return GL_COMPRESSED_RGBA_BPTC_UNORM_ARB;
+	case image::CompressedData::TYPE_BC7srgb:
+		return GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB;
+	default:
+		return GL_RGBA8;
+	}
+}
+
 bool Image::hasNpot()
 {
 	return GLEE_VERSION_2_0 || GLEE_ARB_texture_non_power_of_two;
@@ -427,6 +541,37 @@ bool Image::hasMipmapSharpnessSupport()
 	return GLEE_VERSION_1_4 || GLEE_EXT_texture_lod_bias;
 }

+bool Image::hasCompressedTextureSupport()
+{
+	return GLEE_VERSION_1_3 || GLEE_ARB_texture_compression;
+}
+
+bool Image::hasCompressedTextureSupport(image::CompressedData::TextureType type)
+{
+	if (!hasCompressedTextureSupport())
+		return false;
+
+	switch (type)
+	{
+	case image::CompressedData::TYPE_DXT1:
+	case image::CompressedData::TYPE_DXT3:
+	case image::CompressedData::TYPE_DXT5:
+		return GLEE_EXT_texture_compression_s3tc;
+
+	case image::CompressedData::TYPE_BC5:
+	case image::CompressedData::TYPE_BC5s:
+		return (GLEE_VERSION_3_0 || GLEE_ARB_texture_compression_rgtc || GLEE_EXT_texture_compression_rgtc);
+
+	case image::CompressedData::TYPE_BC7:
+	case image::CompressedData::TYPE_BC7srgb:
+		return (GLEE_VERSION_4_2 || GLEE_ARB_texture_compression_bptc);
+
+	default:
+		return false;
+
+	}
+}
+
 } // opengl
 } // graphics
 } // love
@@ -26,6 +26,7 @@
 #include "common/math.h"
 #include "common/config.h"
 #include "image/ImageData.h"
+#include "image/CompressedData.h"
 #include "graphics/Image.h"

 // OpenGL
@@ -52,10 +53,17 @@ public:
 	 * Creates a new Image. Not that anything is ready to use
 	 * before load is called.
 	 *
-	 * @param file The file from which to load the image.
+	 * @param data The data from which to load the image.
 	 **/
 	Image(love::image::ImageData *data);

+	/**
+	 * Creates a new Image with compressed image data.
+	 *
+	 * @param cdata The compressed data from which to load the image.
+	 **/
+	Image(love::image::CompressedData *cdata);
+
 	/**
 	 * Destructor. Deletes the hardware texture and other resources.
 	 **/
@@ -68,20 +76,6 @@ public:

 	love::image::ImageData *getData() const;

-	/**
-	 * Generate vertices according to a subimage.
-	 *
-	 * Note: out-of-range values will be clamped.
-	 * Note: the vertex colors will not be changed.
-	 *
-	 * @param x The top-left corner of the subimage along the x-axis.
-	 * @param y The top-left corner of the subimage along the y-axis.
-	 * @param w The width of the subimage.
-	 * @param h The height of the subimage.
-	 * @param vertices A vertex array of size four.
-	 **/
-	void getRectangleVertices(int x, int y, int w, int h, vertex *vertices) const;
-
 	/**
 	 * @copydoc Drawable::draw()
 	 **/
@@ -107,6 +101,11 @@ public:
 	void setMipmapSharpness(float sharpness);
 	float getMipmapSharpness() const;

+	/**
+	 * Whether this Image is using a compressed texture (via CompressedData).
+	 **/
+	bool isCompressed() const;
+
 	void bind() const;

 	bool load();
@@ -126,6 +125,9 @@ public:
 	static bool hasMipmapSupport();
 	static bool hasMipmapSharpnessSupport();

+	static bool hasCompressedTextureSupport();
+	static bool hasCompressedTextureSupport(image::CompressedData::TextureType type);
+
 private:

 	void drawv(const Matrix &t, const vertex *v) const;
@@ -135,9 +137,15 @@ private:
 	{
 		return texture;
 	}
-	// The ImageData from which the texture is created.
+
+	// The ImageData from which the texture is created. May be null if
+	// Compressed image data was used to create the texture.
 	love::image::ImageData *data;

+	// Or the Compressed Image Data from which the texture is created. May be
+	// null if raw ImageData was used to create the texture.
+	love::image::CompressedData *cdata;
+
 	// Width and height of the hardware texture.
 	float width, height;

@@ -153,15 +161,22 @@ private:
 	// True if mipmaps have been created for this Image.
 	bool mipmapsCreated;

+	// Whether this Image is using a compressed texture.
+	bool compressed;
+
 	// The image's filter mode
 	Image::Filter filter;

 	// The image's wrap mode
 	Image::Wrap wrap;

+	void preload();
+
 	bool loadVolatilePOT();
 	bool loadVolatileNPOT();

+	void uploadCompressedMipmaps();
+	void createMipmaps();
 	void checkMipmapsCreated();

 	static float maxMipmapSharpness;
@@ -169,6 +184,8 @@ private:
 	static FilterMode defaultMipmapFilter;
 	static float defaultMipmapSharpness;

+	GLenum getCompressedFormat(image::CompressedData::TextureType type) const;
+
 }; // Image

 } // opengl
@@ -97,6 +97,14 @@ void initializeContext()
 		glUnmapBufferARB = (GLEEPFNGLUNMAPBUFFERARBPROC) glUnmapBuffer;
 	}

+	// Same deal for compressed textures.
+	if (GLEE_VERSION_1_3 && !GLEE_ARB_texture_compression)
+	{
+		glCompressedTexImage2DARB = (GLEEPFNGLCOMPRESSEDTEXIMAGE2DARBPROC) glCompressedTexImage2D;
+		glCompressedTexSubImage2DARB = (GLEEPFNGLCOMPRESSEDTEXSUBIMAGE2DARBPROC) glCompressedTexSubImage2D;
+		glGetCompressedTexImageARB = (GLEEPFNGLGETCOMPRESSEDTEXIMAGEARBPROC) glGetCompressedTexImage;
+	}
+
 	if (GLEE_EXT_texture_filter_anisotropic)
 		glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &maxAnisotropy);
 	else
@@ -158,7 +158,14 @@ int w_present(lua_State *)
 int w_setIcon(lua_State *L)
 {
 	Image *image = luax_checktype<Image>(L, 1, "Image", GRAPHICS_IMAGE_T);
-	instance->setIcon(image);
+	try
+	{
+		instance->setIcon(image);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
 	return 0;
 }

@@ -269,21 +276,45 @@ int w_setInvertedStencil(lua_State *L)

 int w_newImage(lua_State *L)
 {
-	// Convert to File, if necessary.
-	if (lua_isstring(L, 1))
-		luax_convobj(L, 1, "filesystem", "newFile");
+	love::image::ImageData *data = 0;
+	love::image::CompressedData *cdata = 0;

-	// Convert to ImageData, if necessary.
-	if (luax_istype(L, 1, FILESYSTEM_FILE_T))
-		luax_convobj(L, 1, "image", "newImageData");
+	// Convert to FileData, if necessary.
+	if (lua_isstring(L, 1) || luax_istype(L, 1, FILESYSTEM_FILE_T))
+		luax_convobj(L, 1, "filesystem", "newFileData");

-	love::image::ImageData *data = luax_checktype<love::image::ImageData>(L, 1, "ImageData", IMAGE_IMAGE_DATA_T);
+	// Convert to ImageData/CompressedData, if necessary.
+	if (luax_istype(L, 1, FILESYSTEM_FILE_DATA_T))
+	{
+		// Determine whether to convert to ImageData or CompressedData.
+		luax_getfunction(L, "image", "isCompressed");
+		lua_pushvalue(L, 1);
+		lua_call(L, 1, 1);
+
+		bool compressed = luax_toboolean(L, -1);
+		lua_pop(L, 1);
+
+		if (compressed)
+			luax_convobj(L, 1, "image", "newCompressedData");
+		else
+			luax_convobj(L, 1, "image", "newImageData");
+	}
+
+	if (luax_istype(L, 1, IMAGE_COMPRESSED_DATA_T))
+		cdata = luax_checktype<love::image::CompressedData>(L, 1, "CompressedData", IMAGE_COMPRESSED_DATA_T);
+	else
+		data = luax_checktype<love::image::ImageData>(L, 1, "ImageData", IMAGE_IMAGE_DATA_T);

 	// Create the image.
 	Image *image = 0;
 	try
 	{
-		image = instance->newImage(data);
+		if (cdata)
+			image = instance->newImage(cdata);
+		else if (data)
+			image = instance->newImage(data);
+		else
+			throw love::Exception("Error creating image.");
 	}
 	catch(love::Exception &e)
 	{
@@ -387,7 +418,7 @@ int w_newImageFont(lua_State *L)
 	int startIndex = 2;

 	// Convert to ImageData if necessary.
-	if (lua_isstring(L, 1) || luax_istype(L, 1, FILESYSTEM_FILE_T) || (luax_istype(L, 1, DATA_T) && !luax_istype(L, 1, IMAGE_IMAGE_DATA_T)))
+	if (lua_isstring(L, 1) || luax_istype(L, 1, FILESYSTEM_FILE_T) || luax_istype(L, 1, FILESYSTEM_FILE_DATA_T))
 		luax_convobj(L, 1, "image", "newImageData");
 	else if (luax_istype(L, 1, GRAPHICS_IMAGE_T))
 	{
@@ -395,6 +426,8 @@ int w_newImageFont(lua_State *L)
 		img_filter = i->getFilter();
 		setFilter = true;
 		love::image::ImageData *id = i->getData();
+		if (!id)
+			return luaL_argerror(L, 1, "image cannot be compressed");
 		luax_newtype(L, "ImageData", IMAGE_IMAGE_DATA_T, (void *)id, false);
 		lua_replace(L, 1);
 	}
@@ -1110,6 +1143,18 @@ int w_isSupported(lua_State *L)
 			if (!Image::hasMipmapSupport())
 				supported = false;
 			break;
+		case Graphics::SUPPORT_DXT:
+			if (!Image::hasCompressedTextureSupport(image::CompressedData::TYPE_DXT5))
+				supported = false;
+			break;
+		case Graphics::SUPPORT_BC5:
+			if (!Image::hasCompressedTextureSupport(image::CompressedData::TYPE_BC5))
+				supported = false;
+			break;
+		case Graphics::SUPPORT_BC7:
+			if (!Image::hasCompressedTextureSupport(image::CompressedData::TYPE_BC7))
+				supported = false;
+			break;
 		default:
 			supported = false;
 		}
@@ -175,6 +175,13 @@ int w_Image_getWrap(lua_State *L)
 	return 2;
 }

+int w_Image_isCompressed(lua_State *L)
+{
+	Image *i = luax_checkimage(L, 1);
+	luax_pushboolean(L, i->isCompressed());
+	return 1;
+}
+
 static const luaL_Reg functions[] =
 {
 	{ "getWidth", w_Image_getWidth },
@@ -186,6 +193,7 @@ static const luaL_Reg functions[] =
 	{ "getWrap", w_Image_getWrap },
 	{ "setMipmapFilter", w_Image_setMipmapFilter },
 	{ "getMipmapFilter", w_Image_getMipmapFilter },
+	{ "isCompressed", w_Image_isCompressed },
 	{ 0, 0 }
 };

@@ -42,6 +42,7 @@ int w_Image_setMipmapFilter(lua_State *L);
 int w_Image_getMipmapFilter(lua_State *L);
 int w_Image_setWrap(lua_State *L);
 int w_Image_getWrap(lua_State *L);
+int w_Image_isCompressed(lua_State *L);
 extern "C" int luaopen_image(lua_State *L);

 } // opengl
@@ -0,0 +1,127 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "CompressedData.h"
+
+namespace love
+{
+namespace image
+{
+
+CompressedData::CompressedData()
+	: type(TYPE_UNKNOWN)
+{
+}
+
+CompressedData::~CompressedData()
+{
+}
+
+int CompressedData::getSize() const
+{
+	// Adding up the total size for all mipmap levels would make more sense, but
+	// it's probably better for getSize() to match getData() so no bad memory
+	// accesses happen...
+	if (dataImages.size() > 0)
+		return dataImages[0].size;
+	else
+		return 0;
+}
+
+void *CompressedData::getData() const
+{
+	// Data for different mipmap levels is not stored contiguously in memory, so
+	// getData() won't work properly for CompressedData.
+	if (dataImages.size() > 0)
+		return (void *) &(dataImages[0].data[0]);
+	else
+		return 0;
+}
+
+int CompressedData::getNumMipmaps() const
+{
+	return dataImages.size();
+}
+
+int CompressedData::getSize(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return dataImages[miplevel].size;
+}
+
+void *CompressedData::getData(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return (void *) &dataImages[miplevel].data[0];
+}
+
+int CompressedData::getWidth(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return dataImages[miplevel].width;
+}
+
+int CompressedData::getHeight(int miplevel) const
+{
+	checkMipmapLevelExists(miplevel);
+
+	return dataImages[miplevel].height;
+}
+
+CompressedData::TextureType CompressedData::getType() const
+{
+	return type;
+}
+
+void CompressedData::checkMipmapLevelExists(int miplevel) const
+{
+	if (miplevel < 0 || miplevel >= dataImages.size())
+		throw love::Exception("Mipmap level %d does not exist", miplevel);
+}
+
+bool CompressedData::getConstant(const char *in, CompressedData::TextureType &out)
+{
+	return types.find(in, out);
+}
+
+bool CompressedData::getConstant(CompressedData::TextureType in, const char *&out)
+{
+	return types.find(in, out);
+}
+
+StringMap<CompressedData::TextureType, CompressedData::TYPE_MAX_ENUM>::Entry CompressedData::typeEntries[] =
+{
+	{"unknown", CompressedData::TYPE_UNKNOWN},
+	{"dxt1", CompressedData::TYPE_DXT1},
+	{"dxt3", CompressedData::TYPE_DXT3},
+	{"dxt5", CompressedData::TYPE_DXT5},
+	{"bc5", CompressedData::TYPE_BC5},
+	{"bc5s", CompressedData::TYPE_BC5s},
+	{"bc7", CompressedData::TYPE_BC7},
+	{"bc7srgb", CompressedData::TYPE_BC7srgb},
+};
+
+StringMap<CompressedData::TextureType, CompressedData::TYPE_MAX_ENUM> CompressedData::types(CompressedData::typeEntries, sizeof(CompressedData::typeEntries));
+
+} // image
+} // love
@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_COMPRESSED_DATA_H
+#define LOVE_IMAGE_COMPRESSED_DATA_H
+
+// LOVE
+#include "common/Data.h"
+#include "common/StringMap.h"
+#include "thread/threads.h"
+
+using love::thread::Mutex;
+
+// STL
+#include <vector>
+
+namespace love
+{
+namespace image
+{
+
+// CompressedData represents image data which is designed to be uploaded to the
+// GPU and rendered in its compressed form, without being un-compressed.
+// http://renderingpipeline.com/2012/07/texture-compression/
+
+class CompressedData : public Data
+{
+public:
+
+	// Types of compressed image data.
+	enum TextureType
+	{
+		TYPE_UNKNOWN,
+		TYPE_DXT1,
+		TYPE_DXT3,
+		TYPE_DXT5,
+		TYPE_BC5,
+		TYPE_BC5s,
+		TYPE_BC7,
+		TYPE_BC7srgb,
+		TYPE_MAX_ENUM
+	};
+
+	// Compressed image data can have multiple mipmap levels, each represented
+	// by a sub-image.
+	struct SubImage
+	{
+		int width, height;
+		size_t size;
+		std::vector<unsigned char> data;
+	};
+
+	CompressedData();
+	virtual ~CompressedData();
+
+	// Implements Data. Note that data for different mipmap levels is not always
+	// stored contiguously in memory, so getData() and getSize() don't make
+	// much sense. Use getData(miplevel) and getSize(mipleveL) instead.
+	virtual void *getData() const;
+	virtual int getSize() const;
+
+	/**
+	 * Gets the number of mipmaps in this CompressedData.
+	 * Includes the base image level.
+	 **/
+	int getNumMipmaps() const;
+
+	/**
+	 * Gets the size in bytes of a sub-image at the specified mipmap level.
+	 **/
+	int getSize(int miplevel) const;
+
+	/**
+	 * Gets the byte data of a sub-image at the specified mipmap level.
+	 **/
+	void *getData(int miplevel) const;
+
+	/**
+	 * Gets the width of a sub-image at the specified mipmap level.
+	 **/
+	int getWidth(int miplevel) const;
+
+	/**
+	 * Gets the height of a sub-image at the specified mipmap level.
+	 **/
+	int getHeight(int miplevel) const;
+
+	/**
+	 * Gets the type of the compressed data.
+	 **/
+	TextureType getType() const;
+
+	static bool getConstant(const char *in, TextureType &out);
+	static bool getConstant(TextureType in, const char *&out);
+
+protected:
+
+	TextureType type;
+
+	// Texture info for each mipmap level.
+	std::vector<SubImage> dataImages;
+
+	void checkMipmapLevelExists(int miplevel) const;
+
+private:
+
+	static StringMap<TextureType, TYPE_MAX_ENUM>::Entry typeEntries[];
+	static StringMap<TextureType, TYPE_MAX_ENUM> types;
+
+}; // CompressedData
+
+} // image
+} // love
+
+#endif // LOVE_IMAGE_COMPRESSED_DATA_H
@@ -26,6 +26,7 @@
 #include "common/Module.h"
 #include "filesystem/File.h"
 #include "ImageData.h"
+#include "CompressedData.h"

 namespace love
 {
@@ -34,8 +35,10 @@ namespace image

 /**
 * This module is responsible for decoding files such as PNG, GIF, JPEG
- * into raw pixel data. This module does not know how to draw images on
- * screen; only love.graphics knows that.
+ * into raw pixel data, as well as parsing compressed formats which are designed
+ * to be uploaded to the GPU and rendered without being un-compressed.
+ * This module does not know how to draw images on screen; only love.graphics
+ * knows that.
 **/
 class Image : public Module
 {
@@ -47,18 +50,11 @@ public:
 	virtual ~Image() {};

 	/**
-	 * Creates new ImageData from a file.
-	 * @param file The file containing the encoded image data.
+	 * Creates new ImageData from FileData.
+	 * @param data The FileData containing the encoded image data.
 	 * @return The new ImageData.
 	 **/
-	virtual ImageData *newImageData(love::filesystem::File *file) = 0;
-
-	/**
-	 * Creates new ImageData from a raw Data.
-	 * @param data The object containing encoded pixel data.
-	 * @return The new ImageData.
-	 **/
-	virtual ImageData *newImageData(Data *data) = 0;
+	virtual ImageData *newImageData(love::filesystem::FileData *data) = 0;

 	/**
 	 * Creates empty ImageData with the given size.
@@ -77,6 +73,19 @@ public:
 	 **/
 	virtual ImageData *newImageData(int width, int height, void *data) = 0;

+	/**
+	 * Creates new CompressedData from FileData.
+	 * @param data The FileData containing the compressed image data.
+	 * @return The new CompressedData.
+	 **/
+	virtual CompressedData *newCompressedData(love::filesystem::FileData *data) = 0;
+
+	/**
+	 * Determines whether a FileData is Compressed image data or not.
+	 * @param data The FileData to test.
+	 **/
+	virtual bool isCompressed(love::filesystem::FileData *data) = 0;
+
 }; // Image

 } // image
@@ -20,8 +20,6 @@

 #include "ImageData.h"

-#include <stdio.h>
-
 using love::thread::Lock;

 namespace love
@@ -30,6 +28,7 @@ namespace image
 {

 ImageData::ImageData()
+	: data(0)
 {
 	mutex = thread::newMutex();
 }
@@ -39,14 +38,19 @@ ImageData::~ImageData()
 	delete mutex;
 }

+int ImageData::getSize() const
+{
+	return getWidth()*getHeight()*sizeof(pixel);
+}
+
 void *ImageData::getData() const
 {
 	return data;
 }

-int ImageData::getSize() const
+bool ImageData::inside(int x, int y) const
 {
-	return getWidth()*getHeight()*sizeof(pixel);
+	return x >= 0 && x < getWidth() && y >= 0 && y < getHeight();
 }

 int ImageData::getWidth() const
@@ -59,11 +63,6 @@ int ImageData::getHeight() const
 	return height;
 }

-bool ImageData::inside(int x, int y) const
-{
-	return x >= 0 && x < getWidth() && y >= 0 && y < getHeight();
-}
-
 void ImageData::setPixel(int x, int y, pixel c)
 {
 	if (!inside(x, y))
@@ -45,22 +45,6 @@ struct pixel
 **/
 class ImageData : public Data
 {
-protected:
-
-	// The width of the image data.
-	int width;
-
-	// The height of the image data.
-	int height;
-
-	// The actual data.
-	unsigned char *data;
-
-	// We need to be thread-safe
-	// so we lock when we're accessing our
-	// data
-	Mutex *mutex;
-
 public:

 	enum Format
@@ -137,10 +121,27 @@ public:
 	virtual void encode(love::filesystem::File *f, Format format) = 0;

 	// Implements Data.
-	void *getData() const;
-	int getSize() const;
+	virtual void *getData() const;
+	virtual int getSize() const;
+
+protected:
+
+	// The width of the image data.
+	int width;
+
+	// The height of the image data.
+	int height;
+
+	// The actual data.
+	unsigned char *data;
+
+	// We need to be thread-safe
+	// so we lock when we're accessing our
+	// data
+	Mutex *mutex;

 private:
+
 	static StringMap<Format, FORMAT_MAX_ENUM>::Entry formatEntries[];
 	static StringMap<Format, FORMAT_MAX_ENUM> formats;

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "CompressedData.h"
+
+#include "ddsHandler.h"
+
+namespace love
+{
+namespace image
+{
+namespace magpie
+{
+
+CompressedData::CompressedData(love::filesystem::FileData *data)
+{
+	load(data);
+}
+
+CompressedData::~CompressedData()
+{
+}
+
+void CompressedData::load(love::filesystem::FileData *data)
+{
+	// SubImage vector will be populated by a parser.
+	std::vector<SubImage> parsedimages;
+	TextureType textype = TYPE_UNKNOWN;
+
+	if (ddsHandler::canParse(data))
+		textype = ddsHandler::parse(data, parsedimages);
+
+	if (textype == TYPE_UNKNOWN)
+		throw love::Exception("Could not parse compressed data: Unknown format.");
+
+	if (parsedimages.size() == 0)
+		throw love::Exception("Could not parse compressed data: No valid data?");
+
+	dataImages = parsedimages;
+	type = textype;
+}
+
+bool CompressedData::isCompressed(love::filesystem::FileData *data)
+{
+	if (ddsHandler::canParse(data))
+		return true;
+
+	return false;
+}
+
+} // magpie
+} // image
+} // love
@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_MAGPIE_COMPRESSED_DATA_H
+#define LOVE_IMAGE_MAGPIE_COMPRESSED_DATA_H
+
+// LOVE
+#include "filesystem/FileData.h"
+#include "image/CompressedData.h"
+
+namespace love
+{
+namespace image
+{
+namespace magpie
+{
+
+class CompressedData : public love::image::CompressedData
+{
+public:
+
+	CompressedData(love::filesystem::FileData *data);
+	virtual ~CompressedData();
+
+	static bool isCompressed(love::filesystem::FileData *data);
+
+private:
+
+	void load(love::filesystem::FileData *data);
+
+}; // CompressedData
+
+} // magpie
+} // image
+} // love
+
+#endif // LOVE_IMAGE_MAGPIE_COMPRESSED_DATA_H
@@ -18,16 +18,15 @@
 * 3. This notice may not be removed or altered from any source distribution.
 **/

-#include "ImageData.h"
-
-// STD
-#include <cstring>
-#include <iostream>
+#include "DevilHandler.h"

 // LOVE
 #include "common/Exception.h"
 #include "common/math.h"
-#include "filesystem/File.h"
+#include "thread/threads.h"
+
+// DevIL
+#include <IL/il.h>

 using love::thread::Lock;

@@ -37,7 +36,7 @@ namespace love
 {
 namespace image
 {
-namespace devil
+namespace magpie
 {

 static inline void ilxClearErrors()
@@ -45,81 +44,61 @@ static inline void ilxClearErrors()
 	while (ilGetError() != IL_NO_ERROR);
 }

-ImageData::ImageData(Data *data)
+void DevilHandler::init()
 {
-	load(data);
+	ilInit();
+	ilEnable(IL_ORIGIN_SET);
+	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
 }

-ImageData::ImageData(filesystem::File *file)
+void DevilHandler::quit()
 {
-	Data *data = file->read();
-	try
+	ilShutDown();
+}
+
+bool DevilHandler::canDecode(love::filesystem::FileData *data)
+{
+	// DevIL can decode a lot of formats...
+	return true;
+}
+
+bool DevilHandler::canEncode(ImageData::Format format)
+{
+	switch (format)
 	{
-		load(data);
-	}
-	catch (love::Exception &)
-	{
-		data->release();
-		throw;
-	}
-	data->release();
-}
-
-ImageData::ImageData(int width, int height)
-{
-	this->width = width;
-	this->height = height;
-	create(width, height);
-
-	// Set to black.
-	memset(data, 0, width*height*4);
-}
-
-ImageData::ImageData(int width, int height, void *data)
-{
-	this->width = width;
-	this->height = height;
-	create(width, height, data);
-}
-
-ImageData::~ImageData()
-{
-	delete[] data;
-}
-
-void ImageData::create(int width, int height, void *data)
-{
-	try
-	{
-		this->data = new unsigned char[width*height*sizeof(pixel)];
-	}
-	catch(std::bad_alloc &)
-	{
-		throw love::Exception("Out of memory");
+	case ImageData::FORMAT_BMP:
+	case ImageData::FORMAT_TGA:
+	case ImageData::FORMAT_JPG:
+	case ImageData::FORMAT_PNG:
+		return true;
+	default:
+		return false;
 	}

-	if (data)
-		memcpy(this->data, data, width*height*sizeof(pixel));
+	return false;
 }

-void ImageData::load(Data *data)
+DevilHandler::DecodedImage DevilHandler::decode(love::filesystem::FileData *data)
 {
 	if (!devilMutex)
 		devilMutex = thread::newMutex();

 	Lock lock(devilMutex);
+
 	ILuint image = ilGenImage();
 	ilBindImage(image);

+	DecodedImage img;
+
 	try
 	{
-		bool success = IL_TRUE == ilLoadL(IL_TYPE_UNKNOWN, (void *)data->getData(), data->getSize());
+		bool success = ilLoadL(IL_TYPE_UNKNOWN, (void *)data->getData(), data->getSize()) == IL_TRUE;

 		if (!success)
 			throw love::Exception("Could not decode image!");

-		width = ilGetInteger(IL_IMAGE_WIDTH);
-		height = ilGetInteger(IL_IMAGE_HEIGHT);
+		img.width = ilGetInteger(IL_IMAGE_WIDTH);
+		img.height = ilGetInteger(IL_IMAGE_HEIGHT);

 		// Make sure the image is in RGBA format.
 		ilConvertImage(IL_RGBA, IL_UNSIGNED_BYTE);
@@ -129,7 +108,18 @@ void ImageData::load(Data *data)
 		if (bpp != sizeof(pixel))
 			throw love::Exception("Could not convert image!");

-		create(width, height, ilGetData());
+		img.size = ilGetInteger(IL_IMAGE_SIZE_OF_DATA);
+
+		try
+		{
+			img.data = new ILubyte[img.size];
+		}
+		catch (std::bad_alloc &)
+		{
+			throw love::Exception("Out of memory.");
+		}
+
+		memcpy(img.data, ilGetData(), img.size);
 	}
 	catch (std::exception &e)
 	{
@@ -139,25 +129,26 @@ void ImageData::load(Data *data)
 	}

 	ilDeleteImage(image);
+
+	return img;
 }

-void ImageData::encode(love::filesystem::File *f, ImageData::Format format)
+DevilHandler::EncodedImage DevilHandler::encode(const DecodedImage &img, ImageData::Format format)
 {
 	if (!devilMutex)
 		devilMutex = thread::newMutex();

-	Lock lock1(devilMutex);
-	Lock lock2(mutex);
+	Lock lock(devilMutex);

 	ILuint tempimage = ilGenImage();
 	ilBindImage(tempimage);
 	ilxClearErrors();

-	ILubyte *encoded_data = NULL;
+	EncodedImage encodedimage;

 	try
 	{
-		bool success = IL_TRUE == ilTexImage(width, height, 1, sizeof(pixel), IL_RGBA, IL_UNSIGNED_BYTE, this->data);
+		bool success = ilTexImage(img.width, img.height, 1, sizeof(pixel), IL_RGBA, IL_UNSIGNED_BYTE, img.data) ==  IL_TRUE;

 		ILenum err = ilGetError();
 		ilxClearErrors();
@@ -202,37 +193,34 @@ void ImageData::encode(love::filesystem::File *f, ImageData::Format format)
 			break;
 		}

-		ILuint size = ilSaveL(ilFormat, NULL, 0);
-		if (!size)
+		encodedimage.size = ilSaveL(ilFormat, NULL, 0);
+		if (!encodedimage.size)
 			throw love::Exception("Could not encode image!");

 		try
 		{
-			encoded_data = new ILubyte[size];
+			encodedimage.data = new ILubyte[encodedimage.size];
 		}
 		catch(std::bad_alloc &)
 		{
 			throw love::Exception("Out of memory");
 		}

-		ilSaveL(ilFormat, encoded_data, size);
-
-		f->open(love::filesystem::File::WRITE);
-		f->write(encoded_data, size);
-		f->close();
+		ilSaveL(ilFormat, encodedimage.data, encodedimage.size);
 	}
 	catch (std::exception &e)
 	{
 		// catches love and std exceptions
 		ilDeleteImage(tempimage);
-		delete[] encoded_data;
+		delete[] encodedimage.data;
 		throw love::Exception("%s", e.what());
 	}

 	ilDeleteImage(tempimage);
-	delete[] encoded_data;
+
+	return encodedimage;
 }

-} // devil
+} // magpie
 } // image
 } // love
@@ -0,0 +1,59 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_MAGPIE_DEVIL_HANDLER_H
+#define LOVE_IMAGE_MAGPIE_DEVIL_HANDLER_H
+
+// LOVE
+#include "filesystem/FileData.h"
+#include "FormatHandler.h"
+
+namespace love
+{
+namespace image
+{
+namespace magpie
+{
+
+/**
+ * Interface between ImageData and DevIL.
+ **/
+class DevilHandler : public FormatHandler
+{
+public:
+
+	static void init();
+	static void quit();
+
+	// Implements FormatHandler.
+
+	static bool canDecode(love::filesystem::FileData *data);
+	static bool canEncode(ImageData::Format format);
+
+	static DecodedImage decode(love::filesystem::FileData *data);
+	static EncodedImage encode(const DecodedImage &img, ImageData::Format format);
+
+}; // DevilHandler
+
+} // magpie
+} // image
+} // love
+
+#endif // LOVE_IMAGE_MAGPIE_DEVIL_HANDLER_H
@@ -0,0 +1,94 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_MAGPIE_FORMAT_HANDLER_H
+#define LOVE_IMAGE_MAGPIE_FORMAT_HANDLER_H
+
+// LOVE
+#include "image/ImageData.h"
+#include "filesystem/FileData.h"
+
+namespace love
+{
+namespace image
+{
+namespace magpie
+{
+
+/**
+ * Base class for all ImageData encoder/decoder library interfaces.
+ **/
+class FormatHandler
+{
+public:
+
+	// Raw RGBA pixel data.
+	struct DecodedImage
+	{
+		int width, height;
+		size_t size;
+		unsigned char *data;
+		DecodedImage() : width(0), height(0), size(0), data(0) {};
+	};
+
+	// Pixel data encoded in a particular format.
+	struct EncodedImage
+	{
+		size_t size;
+		unsigned char *data;
+		EncodedImage() : size(0), data(0) {};
+	};
+
+	// Lets pretend we have virtual static methods...
+
+	/**
+	 * Determines whether a particular FileData can be decoded by this handler.
+	 * @param data The data to decode.
+	 **/
+	// virtual static bool canDecode(love::filesystem::FileData *data) = 0;
+
+	/**
+	 * Determines whether this handler can encode to a particular format.
+	 * @param format The format to encode to.
+	 **/
+	// virtual static bool canEncode(ImageData::Format format) = 0;
+
+	/**
+	 * Decodes an image from its encoded form into raw pixel data.
+	 * @param data The encoded data to decode.
+	 * @return The decoded pixel data.
+	 **/
+	// virtual static DecodedImage decode(love::filesystem::FileData *data) = 0;
+
+	/**
+	 * Encodes an image from raw pixel data into a particular format.
+	 * @param img The raw image data to encode.
+	 * @param format The format to encode to.
+	 * @return The encoded image data.
+	 **/
+	// virtual static EncodedImage encode(const DecodedImage &img, ImageData::Format format) = 0;
+
+}; // FormatHandler
+
+} // magpie
+} // image
+} // love
+
+#endif // LOVE_IMAGE_MAGPIE_FORMAT_HANDLER_H
@@ -20,41 +20,34 @@

 #include "Image.h"

-#include "ImageData.h"
+#include "imageData.h"
+#include "CompressedData.h"

-// DevIL
-#include <IL/il.h>
+#include "DevilHandler.h"

 namespace love
 {
 namespace image
 {
-namespace devil
+namespace magpie
 {

 Image::Image()
 {
-	ilInit();
-	ilOriginFunc(IL_ORIGIN_UPPER_LEFT);
-	ilEnable(IL_ORIGIN_SET);
+	DevilHandler::init();
 }

 Image::~Image()
 {
-	ilShutDown();
+	DevilHandler::quit();
 }

 const char *Image::getName() const
 {
-	return "love.image.devil";
+	return "love.image.magpie";
 }

-love::image::ImageData *Image::newImageData(love::filesystem::File *file)
-{
-	return new ImageData(file);
-}
-
-love::image::ImageData *Image::newImageData(Data *data)
+love::image::ImageData *Image::newImageData(love::filesystem::FileData *data)
 {
 	return new ImageData(data);
 }
@@ -69,6 +62,16 @@ love::image::ImageData *Image::newImageData(int width, int height, void *data)
 	return new ImageData(width, height, data);
 }

-} // devil
+love::image::CompressedData *Image::newCompressedData(love::filesystem::FileData *data)
+{
+	return new CompressedData(data);
+}
+
+bool Image::isCompressed(love::filesystem::FileData *data)
+{
+	return CompressedData::isCompressed(data);
+}
+
+} // magpie
 } // image
 } // love
@@ -18,8 +18,8 @@
 * 3. This notice may not be removed or altered from any source distribution.
 **/

-#ifndef LOVE_IMAGE_DEVIL_IMAGE_H
-#define LOVE_IMAGE_DEVIL_IMAGE_H
+#ifndef LOVE_IMAGE_MAGPIE_IMAGE_H
+#define LOVE_IMAGE_MAGPIE_IMAGE_H

 // LOVE
 #include "image/Image.h"
@@ -28,9 +28,14 @@ namespace love
 {
 namespace image
 {
-namespace devil
+namespace magpie
 {

+/**
+ * Similar to love.sound's Lullaby module, love.image.magpie interfaces with
+ * multiple image libraries and determines the correct one to use on a
+ * per-image basis at runtime.
+ **/
 class Image : public love::image::Image
 {
 public:
@@ -41,15 +46,18 @@ public:
 	// Implements Module.
 	const char *getName() const;

-	love::image::ImageData *newImageData(love::filesystem::File *file);
-	love::image::ImageData *newImageData(Data *data);
+	love::image::ImageData *newImageData(love::filesystem::FileData *data);
 	love::image::ImageData *newImageData(int width, int height);
 	love::image::ImageData *newImageData(int width, int height, void *data);

+	love::image::CompressedData *newCompressedData(love::filesystem::FileData *data);
+
+	bool isCompressed(love::filesystem::FileData *data);
+
 }; // Image

-} // devil
+} // magpie
 } // image
 } // love

-#endif // LOVE_IMAGE_DEVIL_IMAGE_H
+#endif // LOVE_IMAGE_MAGPIE_IMAGE_H
@@ -0,0 +1,133 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "ImageData.h"
+
+#include "FormatHandler.h"
+#include "DevilHandler.h"
+
+namespace love
+{
+namespace image
+{
+namespace magpie
+{
+
+ImageData::ImageData(love::filesystem::FileData *data)
+{
+	decode(data);
+}
+
+ImageData::ImageData(int width, int height)
+{
+	this->width = width;
+	this->height = height;
+	create(width, height);
+
+	// Set to black/transparency.
+	memset(data, 0, width*height*sizeof(pixel));
+}
+
+ImageData::ImageData(int width, int height, void *data)
+{
+	this->width = width;
+	this->height = height;
+	create(width, height, data);
+}
+
+ImageData::~ImageData()
+{
+	delete[] data;
+}
+
+void ImageData::create(int width, int height, void *data)
+{
+	try
+	{
+		this->data = new unsigned char[width*height*sizeof(pixel)];
+	}
+	catch(std::bad_alloc &)
+	{
+		throw love::Exception("Out of memory");
+	}
+
+	if (data)
+		memcpy(this->data, data, width*height*sizeof(pixel));
+}
+
+void ImageData::decode(love::filesystem::FileData *data)
+{
+	FormatHandler::DecodedImage decodedimage;
+
+	if (DevilHandler::canDecode(data))
+		decodedimage = DevilHandler::decode(data);
+	else
+		throw love::Exception("Could not decode image: unrecognized format.");
+
+	// The decoder *must* output a 32 bits-per-pixel image.
+	if (decodedimage.size != decodedimage.width*decodedimage.height*sizeof(pixel))
+	{
+		delete[] decodedimage.data;
+		throw love::Exception("Coult not convert image!");
+	}
+
+	if (this->data)
+		delete[] this->data;
+
+	this->width = decodedimage.width;
+	this->height = decodedimage.height;
+	this->data = decodedimage.data;
+}
+
+void ImageData::encode(love::filesystem::File *f, ImageData::Format format)
+{
+	thread::Lock lock(mutex);
+
+	FormatHandler::DecodedImage rawimage;
+	rawimage.width = width;
+	rawimage.height = height;
+	rawimage.size = width*height*sizeof(pixel);
+	rawimage.data = data;
+
+	FormatHandler::EncodedImage encodedimage;
+
+	try
+	{
+		if (DevilHandler::canEncode(format))
+			encodedimage = DevilHandler::encode(rawimage, format);
+		else
+			throw love::Exception("Image format has no suitable encoder.");
+
+		f->open(love::filesystem::File::WRITE);
+		f->write(encodedimage.data, encodedimage.size);
+		f->close();
+	}
+	catch (love::Exception &)
+	{
+		delete[] encodedimage.data;
+		throw;
+	}
+
+	delete[] encodedimage.data;
+}
+
+} // magpie
+} // image
+} // love
@@ -18,49 +18,44 @@
 * 3. This notice may not be removed or altered from any source distribution.
 **/

-#ifndef LOVE_DEVIL_IMAGE_DATA_H
-#define LOVE_DEVIL_IMAGE_DATA_H
+#ifndef LOVE_IMAGE_MAGPIE_IMAGE_DATA_H
+#define LOVE_IMAGE_MAGPIE_IMAGE_DATA_H

 // LOVE
 #include "filesystem/File.h"
 #include "image/ImageData.h"

-// DevIL
-#include <IL/il.h>
-
-
 namespace love
 {
 namespace image
 {
-namespace devil
+namespace magpie
 {

 class ImageData : public love::image::ImageData
 {
+public:
+
+	ImageData(love::filesystem::FileData *data);
+	ImageData(int width, int height);
+	ImageData(int width, int height, void *data);
+	virtual ~ImageData();
+
+	// Implements image::ImageData.
+	virtual void encode(love::filesystem::File *f, ImageData::Format format);
+
 private:

 	// Create imagedata. Initialize with data if not null.
 	void create(int width, int height, void *data = 0);

-	// Load an encoded format.
-	void load(Data *data);
-
-public:
-
-	ImageData(Data *data);
-	ImageData(love::filesystem::File *file);
-	ImageData(int width, int height);
-	ImageData(int width, int height, void *data);
-	virtual ~ImageData();
-
-	// Implements ImageData.
-	void encode(love::filesystem::File *f, Format format);
+	// Decode and load an encoded format.
+	void decode(love::filesystem::FileData *data);

 }; // ImageData

-} // devil
+} // magpie
 } // image
 } // love

-#endif // LOVE_DEVIL_IMAGE_DATA_H
+#endif // LOVE_IMAGE_MAGPIE_IMAGE_DATA_H
@@ -0,0 +1,106 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "ddsHandler.h"
+
+namespace love
+{
+namespace image
+{
+namespace magpie
+{
+
+bool ddsHandler::canParse(const filesystem::FileData *data)
+{
+	if (data->getExtension().compare("dds") != 0)
+		return false;
+
+	return dds::Parser::isCompressedDDS(data->getData(), data->getSize());
+}
+
+CompressedData::TextureType ddsHandler::parse(filesystem::FileData *data, std::vector<CompressedData::SubImage> &images)
+{
+	if (!dds::Parser::isDDS(data->getData(), data->getSize()))
+		throw love::Exception("Could not decode compressed data (not a DDS file?)");
+
+	CompressedData::TextureType textype = CompressedData::TYPE_UNKNOWN;
+
+	try
+	{
+		dds::Parser parser(data->getData(), data->getSize());
+
+		textype = convertFormat(parser.getFormat());
+
+		if (textype == CompressedData::TYPE_UNKNOWN)
+			throw love::Exception("Could not parse compressed data: Unsupported format.");
+
+		if (parser.getNumMipmaps() == 0)
+			throw love::Exception("Could not parse compressed data: No readable texture data.");
+
+		for (size_t i = 0; i < parser.getNumMipmaps(); i++)
+		{
+			const dds::Parser::Image *img = parser.getImageData(i);
+
+			CompressedData::SubImage mip;
+
+			mip.width = img->width;
+			mip.height = img->height;
+			mip.size = img->dataSize;
+			mip.data.insert(mip.data.begin(), &img->data[0], &img->data[mip.size]);
+
+			images.push_back(mip);
+		}
+	}
+	catch (std::exception &e)
+	{
+		throw love::Exception(e.what());
+	}
+
+	return textype;
+}
+
+CompressedData::TextureType ddsHandler::convertFormat(dds::Format ddsformat)
+{
+	switch (ddsformat)
+	{
+	case dds::FORMAT_DXT1:
+		return CompressedData::TYPE_DXT1;
+	case dds::FORMAT_DXT3:
+		return CompressedData::TYPE_DXT3;
+	case dds::FORMAT_DXT5:
+		return CompressedData::TYPE_DXT5;
+	case dds::FORMAT_BC5:
+		return CompressedData::TYPE_BC5;
+	case dds::FORMAT_BC5s:
+		return CompressedData::TYPE_BC5s;
+	case dds::FORMAT_BC7:
+		return CompressedData::TYPE_BC7;
+	case dds::FORMAT_BC7srgb:
+		return CompressedData::TYPE_BC7srgb;
+	default:
+		return CompressedData::TYPE_UNKNOWN;
+	}
+
+	return CompressedData::TYPE_UNKNOWN;
+}
+
+} // magpie
+} // image
+} // love
@@ -0,0 +1,74 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_MAGPIE_DDS_HANDLER_H
+#define LOVE_IMAGE_MAGPIE_DDS_HANDLER_H
+
+// LOVE
+#include "filesystem/FileData.h"
+#include "image/CompressedData.h"
+
+// dds parser
+#include "ddsparse/ddsparse.h"
+
+// STL
+#include <string>
+
+namespace love
+{
+namespace image
+{
+namespace magpie
+{
+
+/**
+ * Interface between CompressedData and the ddsparse library.
+ **/
+class ddsHandler
+{
+public:
+
+	/**
+	 * Determines whether a particular FileData can be parsed as CompressedData
+	 * by this handler.
+	 * @param data The data to parse.
+	 **/
+	static bool canParse(const filesystem::FileData *data);
+
+	/**
+	 * Parses Compressed image data into a list of sub-images.
+	 * @param[in]  data The data to parse.
+	 * @param[out] images The list of sub-images (including byte data for each)
+	 *             parsed from the file data.
+	 * @return The type of CompressedData.
+	 **/
+	static CompressedData::TextureType parse(filesystem::FileData *data, std::vector<CompressedData::SubImage> &images);
+
+private:
+
+	static CompressedData::TextureType convertFormat(dds::Format ddsformat);
+
+}; // ddsHandler
+
+} // magpie
+} // image
+} // love
+
+#endif // LOVE_IMAGE_MAGPIE_DDS_HANDLER_H
@@ -0,0 +1,129 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#include "wrap_CompressedData.h"
+#include "common/wrap_Data.h"
+
+namespace love
+{
+namespace image
+{
+
+CompressedData *luax_checkcompresseddata(lua_State *L, int idx)
+{
+	return luax_checktype<CompressedData>(L, idx, "CompressedData", IMAGE_COMPRESSED_DATA_T);
+}
+
+int w_CompressedData_getWidth(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	int miplevel = luaL_optinteger(L, 2, 1);
+	int width = 0;
+	try
+	{
+		width = t->getWidth(miplevel >= 1 ? miplevel - 1 : 0);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	lua_pushinteger(L, width);
+	return 1;
+}
+
+int w_CompressedData_getHeight(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	int miplevel = luaL_optinteger(L, 2, 1);
+	int height = 0;
+	try
+	{
+		height = t->getHeight(miplevel >= 1 ? miplevel - 1 : 0);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	lua_pushinteger(L, height);
+	return 1;
+}
+
+int w_CompressedData_getDimensions(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	int miplevel = luaL_optinteger(L, 2, 1);
+	int width = 0, height = 0;
+	try
+	{
+		width = t->getWidth(miplevel >= 1 ? miplevel - 1 : 0);
+		height = t->getHeight(miplevel >= 1 ? miplevel - 1 : 0);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	lua_pushinteger(L, width);
+	lua_pushinteger(L, height);
+	return 2;
+}
+
+int w_CompressedData_getNumMipmaps(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+	lua_pushinteger(L, t->getNumMipmaps());
+	return 1;
+}
+
+int w_CompressedData_getType(lua_State *L)
+{
+	CompressedData *t = luax_checkcompresseddata(L, 1);
+
+	image::CompressedData::TextureType type = t->getType();
+	const char *str;
+
+	if (image::CompressedData::getConstant(type, str))
+		lua_pushstring(L, str);
+	else
+		lua_pushstring(L, "unknown");
+
+	return 1;
+}
+
+static const luaL_Reg functions[] =
+{
+	// Data
+//	{ "getPointer", w_Data_getPointer },
+	{ "getSize", w_Data_getSize },
+
+	{ "getWidth", w_CompressedData_getWidth },
+	{ "getHeight", w_CompressedData_getHeight },
+	{ "getDimensions", w_CompressedData_getDimensions },
+	{ "getNumMipmaps", w_CompressedData_getNumMipmaps },
+	{ "getType", w_CompressedData_getType },
+	{ 0, 0 },
+};
+
+extern "C" int luaopen_compresseddata(lua_State *L)
+{
+	return luax_register_type(L, "CompressedData", functions);
+}
+
+} // image
+} // love
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2006-2013 LOVE Development Team
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ **/
+
+#ifndef LOVE_IMAGE_WRAP_COMRESSED_DATA_H
+#define LOVE_IMAGE_WRAP_COMRESSED_DATA_H
+
+// LOVE
+#include "common/runtime.h"
+#include "CompressedData.h"
+
+namespace love
+{
+namespace image
+{
+
+CompressedData *luax_checkcompresseddata(lua_State *L, int idx);
+int w_CompressedData_getWidth(lua_State *L);
+int w_CompressedData_getHeight(lua_State *L);
+int w_CompressedData_getDimensions(lua_State *L);
+int w_CompressedData_getNumMipmaps(lua_State *L);
+int w_CompressedData_getType(lua_State *L);
+extern "C" int luaopen_compresseddata(lua_State *L);
+
+} // image
+} // love
+
+#endif // LOVE_IMAGE_WRAP_COMRESSED_DATA_H
@@ -23,7 +23,7 @@
 #include "common/Data.h"
 #include "common/StringMap.h"

-#include "devil/Image.h"
+#include "magpie/Image.h"

 namespace love
 {
@@ -55,41 +55,70 @@ int w_newImageData(lua_State *L)
 		return 1;
 	}

-	// Case 2: Data
-	if (luax_istype(L, 1, DATA_T))
-	{
-		Data *d = luax_checktype<Data>(L, 1, "Data", DATA_T);
-		ImageData *t = 0;
-		try
-		{
-			t = instance->newImageData(d);
-		}
-		catch(love::Exception &e)
-		{
-			return luaL_error(L, "%s", e.what());
-		}
-		luax_newtype(L, "ImageData", IMAGE_IMAGE_DATA_T, (void *)t);
-		return 1;
-	}
+	// Case 2: File(Data).

-	// Case 3: String/File.
+	// Convert to FileData, if necessary.
+	if (lua_isstring(L, 1) || luax_istype(L, 1, FILESYSTEM_FILE_T))
+		luax_convobj(L, 1, "filesystem", "newFileData");

-	// Convert to File, if necessary.
-	if (lua_isstring(L, 1))
-		luax_convobj(L, 1, "filesystem", "newFile");
-
-	love::filesystem::File *file = luax_checktype<love::filesystem::File>(L, 1, "File", FILESYSTEM_FILE_T);
+	love::filesystem::FileData *data = luax_checktype<love::filesystem::FileData>(L, 1, "FileData", FILESYSTEM_FILE_DATA_T);

 	ImageData *t = 0;
 	try
 	{
-		t = instance->newImageData(file);
+		t = instance->newImageData(data);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+
+	luax_newtype(L, "ImageData", IMAGE_IMAGE_DATA_T, (void *) t);
+
+	return 1;
+}
+
+int w_newCompressedData(lua_State *L)
+{
+	// Convert to FileData, if necessary.
+	if (lua_isstring(L, 1) || luax_istype(L, 1, FILESYSTEM_FILE_T))
+		luax_convobj(L, 1, "filesystem", "newFileData");
+
+	love::filesystem::FileData *data = luax_checktype<love::filesystem::FileData>(L, 1, "FileData", FILESYSTEM_FILE_DATA_T);
+
+	CompressedData *t = 0;
+	try
+	{
+		t = instance->newCompressedData(data);
 	}
 	catch(love::Exception &e)
 	{
 		return luaL_error(L, "%s", e.what());
 	}
-	luax_newtype(L, "ImageData", IMAGE_IMAGE_DATA_T, (void *)t);
+
+	luax_newtype(L, "CompressedData", IMAGE_COMPRESSED_DATA_T, (void *) t);
+
+	return 1;
+}
+
+int w_isCompressed(lua_State *L)
+{
+	// Convert to FileData, if necessary.
+	if (lua_isstring(L, 1) || luax_istype(L, 1, FILESYSTEM_FILE_T))
+		luax_convobj(L, 1, "filesystem", "newFileData");
+
+	love::filesystem::FileData *data = luax_checktype<love::filesystem::FileData>(L, 1, "FileData", FILESYSTEM_FILE_DATA_T);
+
+	bool compressed = false;
+	try
+	{
+		compressed = instance->isCompressed(data);
+	}
+	catch (love::Exception &e)
+	{
+		return luaL_error(L, "%s", e.what());
+	}
+	luax_pushboolean(L, compressed);
 	return 1;
 }

@@ -97,12 +126,15 @@ int w_newImageData(lua_State *L)
 static const luaL_Reg functions[] =
 {
 	{ "newImageData",  w_newImageData },
+	{ "newCompressedData", w_newCompressedData },
+	{ "isCompressed", w_isCompressed },
 	{ 0, 0 }
 };

 static const lua_CFunction types[] =
 {
 	luaopen_imagedata,
+	luaopen_compresseddata,
 	0
 };

@@ -112,7 +144,7 @@ extern "C" int luaopen_love_image(lua_State *L)
 	{
 		try
 		{
-			instance = new love::image::devil::Image();
+			instance = new love::image::magpie::Image();
 		}
 		catch(Exception &e)
 		{
@@ -24,14 +24,16 @@
 // LOVE
 #include "Image.h"
 #include "wrap_ImageData.h"
+#include "wrap_CompressedData.h"

 namespace love
 {
 namespace image
 {

-int w_getFormats(lua_State *L);
 int w_newImageData(lua_State *L);
+int w_newCompressedData(lua_State *L);
+int w_isCompressed(lua_State *L);
 extern "C" LOVE_EXPORT int luaopen_love_image(lua_State *L);

 } // image
@@ -191,7 +191,7 @@ int w_ImageData_encode(lua_State *L)
 static const luaL_Reg functions[] =
 {
 	// Data
-	{ "getPointer", w_Data_getPointer },
+//	{ "getPointer", w_Data_getPointer },
 	{ "getSize", w_Data_getSize },

 	{ "getWidth", w_ImageData_getWidth },
@@ -88,7 +88,7 @@ static const luaL_Reg functions[] =
 {

 	// Data
-	{ "getPointer", w_Data_getPointer },
+//	{ "getPointer", w_Data_getPointer },
 	{ "getSize", w_Data_getSize },

 	{ "getChannels", w_SoundData_getChannels },