| public static DecompressImage ( byte blocks, int width, int height, int flags ) : byte[] | ||
| blocks | byte | |
| width | int | |
| height | int | |
| flags | int | |
| return | byte[] | |
public void Deserialize(Stream input)
{
var pos = input.Position;
unsafe
{
var buffer = new byte[input.Length - pos];
input.Read(buffer, 0, buffer.Length);
TypedReference tr = __makeref(buffer);
IntPtr ptr = **(IntPtr **)(&tr);
string hex = ptr.ToString("X");
string hexOutput = String.Format("Data: 0x{0:X}", hex);
Debug.WriteLine(hexOutput);
}
input.Seek(pos, SeekOrigin.Begin);
var magic = input.ReadValueU32();
if (magic != 0x20534444 &&
magic < 0x44440000 &&
magic > 0x44445000)
{
throw new FormatException("not a DDS texture");
}
this.Endian = Endian.Little; // magic == 0x20534444 ? Endian.Little : Endian.Big;
this.Header = new DDS.Header();
this.Header.Deserialize(input, this.Endian);
if ((this.Header.PixelFormat.Flags & DDS.PixelFormatFlags.FourCC) != 0)
{
var squishFlags = Native.Flags.None;
switch (this.Header.PixelFormat.FourCC)
{
case 0x31545844: // "DXT1"
{
squishFlags |= Native.Flags.DXT1;
break;
}
case 0x33545844: // "DXT3"
{
squishFlags |= Native.Flags.DXT3;
break;
}
case 0x35545844: // "DXT5"
{
squishFlags |= Native.Flags.DXT5;
break;
}
case 0x30315844: // "DXT5"
{
squishFlags |= Native.Flags.DXT5;
break;
}
case 0x32495441: // "ATI"
{
squishFlags |= Native.Flags.DXT5;
break;
}
default:
{
throw new FormatException("unsupported DDS format");
}
}
// Compute size of compressed block area
int blockCount = ((this.Width + 3) / 4) * ((this.Height + 3) / 4);
int blockSize = ((squishFlags & Native.Flags.DXT1) != 0) ? 8 : 16;
// Allocate room for compressed blocks, and read data into it.
var compressedBlocks = new byte[blockCount * blockSize];
input.Read(compressedBlocks, 0, compressedBlocks.Length);
// Now decompress..
this._PixelData = Native.DecompressImage(
compressedBlocks, this.Width, this.Height, squishFlags);
}
else
{
// We can only deal with the non-DXT formats we know about..
// this is a bit of a mess..
// Sorry..
var fileFormat = DDS.FileFormat.INVALID;
if (this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGBA &&
this.Header.PixelFormat.RGBBitCount == 32 &&
this.Header.PixelFormat.RedBitMask == 0x00FF0000 &&
this.Header.PixelFormat.GreenBitMask == 0x0000FF00 &&
this.Header.PixelFormat.BlueBitMask == 0x000000FF &&
this.Header.PixelFormat.AlphaBitMask == 0xFF000000)
{
fileFormat = DDS.FileFormat.A8R8G8B8;
}
else if (
this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGB &&
this.Header.PixelFormat.RGBBitCount == 32 &&
this.Header.PixelFormat.RedBitMask == 0x00FF0000 &&
this.Header.PixelFormat.GreenBitMask == 0x0000FF00 &&
this.Header.PixelFormat.BlueBitMask == 0x000000FF &&
this.Header.PixelFormat.AlphaBitMask == 0x00000000)
{
fileFormat = DDS.FileFormat.X8R8G8B8;
}
else if (
this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGBA &&
this.Header.PixelFormat.RGBBitCount == 32 &&
this.Header.PixelFormat.RedBitMask == 0x000000ff &&
this.Header.PixelFormat.GreenBitMask == 0x0000ff00 &&
this.Header.PixelFormat.BlueBitMask == 0x00ff0000 &&
this.Header.PixelFormat.AlphaBitMask == 0xff000000)
{
fileFormat = DDS.FileFormat.A8B8G8R8;
}
else if (
this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGB &&
this.Header.PixelFormat.RGBBitCount == 32 &&
this.Header.PixelFormat.RedBitMask == 0x000000ff &&
this.Header.PixelFormat.GreenBitMask == 0x0000ff00 &&
this.Header.PixelFormat.BlueBitMask == 0x00ff0000 &&
this.Header.PixelFormat.AlphaBitMask == 0x00000000)
{
fileFormat = DDS.FileFormat.X8B8G8R8;
}
else if (
this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGBA &&
this.Header.PixelFormat.RGBBitCount == 16 &&
this.Header.PixelFormat.RedBitMask == 0x00007c00 &&
this.Header.PixelFormat.GreenBitMask == 0x000003e0 &&
this.Header.PixelFormat.BlueBitMask == 0x0000001f &&
this.Header.PixelFormat.AlphaBitMask == 0x00008000)
{
fileFormat = DDS.FileFormat.A1R5G5B5;
}
else if (
this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGBA &&
this.Header.PixelFormat.RGBBitCount == 16 &&
this.Header.PixelFormat.RedBitMask == 0x00000f00 &&
this.Header.PixelFormat.GreenBitMask == 0x000000f0 &&
this.Header.PixelFormat.BlueBitMask == 0x0000000f &&
this.Header.PixelFormat.AlphaBitMask == 0x0000f000)
{
fileFormat = DDS.FileFormat.A4R4G4B4;
}
else if (
this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGB &&
this.Header.PixelFormat.RGBBitCount == 24 &&
this.Header.PixelFormat.RedBitMask == 0x00ff0000 &&
this.Header.PixelFormat.GreenBitMask == 0x0000ff00 &&
this.Header.PixelFormat.BlueBitMask == 0x000000ff &&
this.Header.PixelFormat.AlphaBitMask == 0x00000000)
{
fileFormat = DDS.FileFormat.R8G8B8;
}
else if (
this.Header.PixelFormat.Flags == DDS.PixelFormatFlags.RGB &&
this.Header.PixelFormat.RGBBitCount == 16 &&
this.Header.PixelFormat.RedBitMask == 0x0000f800 &&
this.Header.PixelFormat.GreenBitMask == 0x000007e0 &&
this.Header.PixelFormat.BlueBitMask == 0x0000001f &&
this.Header.PixelFormat.AlphaBitMask == 0x00000000)
{
fileFormat = DDS.FileFormat.R5G6B5;
}
if (fileFormat == DDS.FileFormat.INVALID)
{
throw new FormatException("unsupported DDS format");
}
int pixelSize = (int)(this.Header.PixelFormat.RGBBitCount / 8);
int rowPitch = 0;
if ((this.Header.Flags & DDS.HeaderFlags.Pitch) != 0)
{
rowPitch = (int)this.Header.PitchOrLinearSize;
}
else if ((this.Header.Flags & DDS.HeaderFlags.LinerSize) != 0)
{
/* Linear size specified, compute row pitch. Of course, this
* should never happen as linear size is *supposed* to be for
* compressed textures. But Microsoft doesn't always play by the
* rules when it comes to DDS output. */
rowPitch =
(int)this.Header.PitchOrLinearSize /
this.Header.Height;
}
else
{
/* Another case of Microsoft not obeying their standard is the
* 'Convert to..' shell extension that ships in the DirectX SDK.
* Seems to always leave flags empty, so no indication of pitch
* or linear size.
*
* And - to top it all off - they leave PitchOrLinearSize as
* *zero*. Zero??? If we get this bizarre set of inputs, we just
* go 'screw it' and compute row pitch ourselves,
*
* Making sure we DWORD align it (if that code path is enabled). */
rowPitch = this.Header.Width * pixelSize;
#if APPLY_PITCH_ALIGNMENT
rowPitch = (((int)rowPitch + 3) & (~3));
#endif
}
var pixelData = new byte[rowPitch * this.Header.Height];
if (input.Read(pixelData, 0, pixelData.Length) != pixelData.Length)
{
throw new EndOfStreamException();
}
this._PixelData = new byte[this.Header.Width * this.Header.Height * 4];
for (int y = 0; y < this.Header.Height; y++)
{
int src = y * rowPitch;
int dst = y * 4;
for (int x = 0; x < this.Header.Width; x++, src += pixelSize, dst += 4)
{
// Read our pixel
uint color = 0;
byte R = 0;
byte G = 0;
byte B = 0;
byte A = 0;
// Build our pixel colour as a DWORD
for (int loop = 0, shift = 0; loop < pixelSize; loop++, shift += 8)
{
color |= (uint)pixelData[src + loop] << shift;
}
switch (fileFormat)
{
case DDS.FileFormat.A8R8G8B8:
{
A = (byte)((color >> 24) & 0xFF);
R = (byte)((color >> 16) & 0xFF);
G = (byte)((color >> 8) & 0xFF);
B = (byte)((color >> 0) & 0xFF);
break;
}
case DDS.FileFormat.X8R8G8B8:
{
A = 0xFF;
R = (byte)((color >> 16) & 0xFF);
G = (byte)((color >> 8) & 0xFF);
B = (byte)((color >> 0) & 0xFF);
break;
}
case DDS.FileFormat.A8B8G8R8:
{
A = (byte)((color >> 24) & 0xFF);
R = (byte)((color >> 0) & 0xFF);
G = (byte)((color >> 8) & 0xFF);
B = (byte)((color >> 16) & 0xFF);
break;
}
case DDS.FileFormat.X8B8G8R8:
{
A = 0xFF;
R = (byte)((color >> 0) & 0xFF);
G = (byte)((color >> 8) & 0xFF);
B = (byte)((color >> 16) & 0xFF);
break;
}
case DDS.FileFormat.A1R5G5B5:
{
A = (byte)((color >> 15) * 0xFF);
R = (byte)((color >> 10) & 0x1F);
G = (byte)((color >> 5) & 0x1F);
B = (byte)((color >> 0) & 0x1F);
R = (byte)((R << 3) | (R >> 2));
G = (byte)((G << 3) | (G >> 2));
B = (byte)((B << 3) | (B >> 2));
break;
}
case DDS.FileFormat.A4R4G4B4:
{
A = (byte)((color >> 12) & 0xFF);
R = (byte)((color >> 8) & 0x0F);
G = (byte)((color >> 4) & 0x0F);
B = (byte)((color >> 0) & 0x0F);
A = (byte)((A << 4) | (A >> 0));
R = (byte)((R << 4) | (R >> 0));
G = (byte)((G << 4) | (G >> 0));
B = (byte)((B << 4) | (B >> 0));
break;
}
case DDS.FileFormat.R8G8B8:
{
A = 0xFF;
R = (byte)((color >> 16) & 0xFF);
G = (byte)((color >> 8) & 0xFF);
B = (byte)((color >> 0) & 0xFF);
break;
}
case DDS.FileFormat.R5G6B5:
{
A = 0xFF;
R = (byte)((color >> 11) & 0x1F);
G = (byte)((color >> 5) & 0x3F);
B = (byte)((color >> 0) & 0x1F);
R = (byte)((R << 3) | (R >> 2));
G = (byte)((G << 2) | (G >> 4));
B = (byte)((B << 3) | (B >> 2));
break;
}
default:
{
throw new NotSupportedException();
}
}
this._PixelData[dst + 0] = R;
this._PixelData[dst + 1] = G;
this._PixelData[dst + 2] = B;
this._PixelData[dst + 3] = A;
}
}
}
}
public void Load(System.IO.Stream input)
{
BinaryReader Utility = new BinaryReader(input);
// Read the DDS tag. If it's not right, then bail..
uint ddsTag = Utility.ReadUInt32( );
if (ddsTag != 0x20534444)
{
throw new FormatException("File does not appear to be a DDS image");
}
// Read everything in.. for now assume it worked like a charm..
m_header.Read(input);
if ((m_header.m_pixelFormat.m_flags & ( int )DdsPixelFormat.PixelFormatFlags.FourCC) != 0)
{
int squishFlags = 0;
switch (m_header.m_pixelFormat.m_fourCC)
{
case 0x31545844:
squishFlags = ( int )Native.SquishFlags.DXT1;
break;
case 0x33545844:
squishFlags = ( int )Native.SquishFlags.DXT3;
break;
case 0x35545844:
squishFlags = ( int )Native.SquishFlags.DXT5;
break;
default:
throw new FormatException("File is not a supported DDS format");
}
// Compute size of compressed block area
int blockCount = ((GetWidth() + 3) / 4) * ((GetHeight() + 3) / 4);
int blockSize = ((squishFlags & ( int )Native.SquishFlags.DXT1) != 0) ? 8 : 16;
// Allocate room for compressed blocks, and read data into it.
byte[] compressedBlocks = new byte[blockCount * blockSize];
input.Read(compressedBlocks, 0, compressedBlocks.GetLength(0));
// Now decompress..
m_pixelData = Native.DecompressImage(compressedBlocks, GetWidth(), GetHeight(), squishFlags);
}
else
{
// We can only deal with the non-DXT formats we know about.. this is a bit of a mess..
// Sorry..
DdsFileFormat fileFormat = DdsFileFormat.INVALID;
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGBA) &&
(m_header.m_pixelFormat.m_rgbBitCount == 32) &&
(m_header.m_pixelFormat.m_rBitMask == 0x00ff0000) && (m_header.m_pixelFormat.m_gBitMask == 0x0000ff00) &&
(m_header.m_pixelFormat.m_bBitMask == 0x000000ff) && (m_header.m_pixelFormat.m_aBitMask == 0xff000000))
{
fileFormat = DdsFileFormat.A8R8G8B8;
}
else
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGB) &&
(m_header.m_pixelFormat.m_rgbBitCount == 32) &&
(m_header.m_pixelFormat.m_rBitMask == 0x00ff0000) && (m_header.m_pixelFormat.m_gBitMask == 0x0000ff00) &&
(m_header.m_pixelFormat.m_bBitMask == 0x000000ff) && (m_header.m_pixelFormat.m_aBitMask == 0x00000000))
{
fileFormat = DdsFileFormat.X8R8G8B8;
}
else
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGBA) &&
(m_header.m_pixelFormat.m_rgbBitCount == 32) &&
(m_header.m_pixelFormat.m_rBitMask == 0x000000ff) && (m_header.m_pixelFormat.m_gBitMask == 0x0000ff00) &&
(m_header.m_pixelFormat.m_bBitMask == 0x00ff0000) && (m_header.m_pixelFormat.m_aBitMask == 0xff000000))
{
fileFormat = DdsFileFormat.A8B8G8R8;
}
else
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGB) &&
(m_header.m_pixelFormat.m_rgbBitCount == 32) &&
(m_header.m_pixelFormat.m_rBitMask == 0x000000ff) && (m_header.m_pixelFormat.m_gBitMask == 0x0000ff00) &&
(m_header.m_pixelFormat.m_bBitMask == 0x00ff0000) && (m_header.m_pixelFormat.m_aBitMask == 0x00000000))
{
fileFormat = DdsFileFormat.X8B8G8R8;
}
else
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGBA) &&
(m_header.m_pixelFormat.m_rgbBitCount == 16) &&
(m_header.m_pixelFormat.m_rBitMask == 0x00007c00) && (m_header.m_pixelFormat.m_gBitMask == 0x000003e0) &&
(m_header.m_pixelFormat.m_bBitMask == 0x0000001f) && (m_header.m_pixelFormat.m_aBitMask == 0x00008000))
{
fileFormat = DdsFileFormat.A1R5G5B5;
}
else
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGBA) &&
(m_header.m_pixelFormat.m_rgbBitCount == 16) &&
(m_header.m_pixelFormat.m_rBitMask == 0x00000f00) && (m_header.m_pixelFormat.m_gBitMask == 0x000000f0) &&
(m_header.m_pixelFormat.m_bBitMask == 0x0000000f) && (m_header.m_pixelFormat.m_aBitMask == 0x0000f000))
{
fileFormat = DdsFileFormat.A4R4G4B4;
}
else
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGB) &&
(m_header.m_pixelFormat.m_rgbBitCount == 24) &&
(m_header.m_pixelFormat.m_rBitMask == 0x00ff0000) && (m_header.m_pixelFormat.m_gBitMask == 0x0000ff00) &&
(m_header.m_pixelFormat.m_bBitMask == 0x000000ff) && (m_header.m_pixelFormat.m_aBitMask == 0x00000000))
{
fileFormat = DdsFileFormat.R8G8B8;
}
else
if ((m_header.m_pixelFormat.m_flags == ( int )DdsPixelFormat.PixelFormatFlags.RGB) &&
(m_header.m_pixelFormat.m_rgbBitCount == 16) &&
(m_header.m_pixelFormat.m_rBitMask == 0x0000f800) && (m_header.m_pixelFormat.m_gBitMask == 0x000007e0) &&
(m_header.m_pixelFormat.m_bBitMask == 0x0000001f) && (m_header.m_pixelFormat.m_aBitMask == 0x00000000))
{
fileFormat = DdsFileFormat.R5G6B5;
}
// If fileFormat is still invalid, then it's an unsupported format.
if (fileFormat == DdsFileFormat.INVALID)
{
throw new FormatException("File is not a supported DDS format");
}
// Size of a source pixel, in bytes
int srcPixelSize = (( int )m_header.m_pixelFormat.m_rgbBitCount / 8);
// We need the pitch for a row, so we can allocate enough memory for the load.
int rowPitch = 0;
if ((m_header.m_headerFlags & ( int )DdsHeader.HeaderFlags.Pitch) != 0)
{
// Pitch specified.. so we can use directly
rowPitch = ( int )m_header.m_pitchOrLinearSize;
}
else
if ((m_header.m_headerFlags & ( int )DdsHeader.HeaderFlags.LinerSize) != 0)
{
// Linear size specified.. compute row pitch. Of course, this should never happen
// as linear size is *supposed* to be for compressed textures. But Microsoft don't
// always play by the rules when it comes to DDS output.
rowPitch = ( int )m_header.m_pitchOrLinearSize / ( int )m_header.m_height;
}
else
{
// Another case of Microsoft not obeying their standard is the 'Convert to..' shell extension
// that ships in the DirectX SDK. Seems to always leave flags empty..so no indication of pitch
// or linear size. And - to cap it all off - they leave pitchOrLinearSize as *zero*. Zero??? If
// we get this bizarre set of inputs, we just go 'screw it' and compute row pitch ourselves,
// making sure we DWORD align it (if that code path is enabled).
rowPitch = (( int )m_header.m_width * srcPixelSize);
#if APPLY_PITCH_ALIGNMENT
rowPitch = ((( int )rowPitch + 3) & (~3));
#endif // APPLY_PITCH_ALIGNMENT
}
// System.Diagnostics.Debug.WriteLine( "Image width : " + m_header.m_width + ", rowPitch = " + rowPitch );
// Ok.. now, we need to allocate room for the bytes to read in from.. it's rowPitch bytes * height
byte[] readPixelData = new byte[rowPitch * m_header.m_height];
input.Read(readPixelData, 0, readPixelData.GetLength(0));
// We now need space for the real pixel data.. that's width * height * 4..
m_pixelData = new byte[m_header.m_width * m_header.m_height * 4];
// And now we have the arduous task of filling that up with stuff..
for (int destY = 0; destY < ( int )m_header.m_height; destY++)
{
for (int destX = 0; destX < ( int )m_header.m_width; destX++)
{
// Compute source pixel offset
int srcPixelOffset = (destY * rowPitch) + (destX * srcPixelSize);
// Read our pixel
uint pixelColour = 0;
uint pixelRed = 0;
uint pixelGreen = 0;
uint pixelBlue = 0;
uint pixelAlpha = 0;
// Build our pixel colour as a DWORD
for (int loop = 0; loop < srcPixelSize; loop++)
{
pixelColour |= ( uint )(readPixelData[srcPixelOffset + loop] << (8 * loop));
}
if (fileFormat == DdsFileFormat.A8R8G8B8)
{
pixelAlpha = (pixelColour >> 24) & 0xff;
pixelRed = (pixelColour >> 16) & 0xff;
pixelGreen = (pixelColour >> 8) & 0xff;
pixelBlue = (pixelColour >> 0) & 0xff;
}
else
if (fileFormat == DdsFileFormat.X8R8G8B8)
{
pixelAlpha = 0xff;
pixelRed = (pixelColour >> 16) & 0xff;
pixelGreen = (pixelColour >> 8) & 0xff;
pixelBlue = (pixelColour >> 0) & 0xff;
}
else
if (fileFormat == DdsFileFormat.A8B8G8R8)
{
pixelAlpha = (pixelColour >> 24) & 0xff;
pixelRed = (pixelColour >> 0) & 0xff;
pixelGreen = (pixelColour >> 8) & 0xff;
pixelBlue = (pixelColour >> 16) & 0xff;
}
else
if (fileFormat == DdsFileFormat.X8B8G8R8)
{
pixelAlpha = 0xff;
pixelRed = (pixelColour >> 0) & 0xff;
pixelGreen = (pixelColour >> 8) & 0xff;
pixelBlue = (pixelColour >> 16) & 0xff;
}
else
if (fileFormat == DdsFileFormat.A1R5G5B5)
{
pixelAlpha = (pixelColour >> 15) * 0xff;
pixelRed = (pixelColour >> 10) & 0x1f;
pixelGreen = (pixelColour >> 5) & 0x1f;
pixelBlue = (pixelColour >> 0) & 0x1f;
pixelRed = (pixelRed << 3) | (pixelRed >> 2);
pixelGreen = (pixelGreen << 3) | (pixelGreen >> 2);
pixelBlue = (pixelBlue << 3) | (pixelBlue >> 2);
}
else
if (fileFormat == DdsFileFormat.A4R4G4B4)
{
pixelAlpha = (pixelColour >> 12) & 0xff;
pixelRed = (pixelColour >> 8) & 0x0f;
pixelGreen = (pixelColour >> 4) & 0x0f;
pixelBlue = (pixelColour >> 0) & 0x0f;
pixelAlpha = (pixelAlpha << 4) | (pixelAlpha >> 0);
pixelRed = (pixelRed << 4) | (pixelRed >> 0);
pixelGreen = (pixelGreen << 4) | (pixelGreen >> 0);
pixelBlue = (pixelBlue << 4) | (pixelBlue >> 0);
}
else
if (fileFormat == DdsFileFormat.R8G8B8)
{
pixelAlpha = 0xff;
pixelRed = (pixelColour >> 16) & 0xff;
pixelGreen = (pixelColour >> 8) & 0xff;
pixelBlue = (pixelColour >> 0) & 0xff;
}
else
if (fileFormat == DdsFileFormat.R5G6B5)
{
pixelAlpha = 0xff;
pixelRed = (pixelColour >> 11) & 0x1f;
pixelGreen = (pixelColour >> 5) & 0x3f;
pixelBlue = (pixelColour >> 0) & 0x1f;
pixelRed = (pixelRed << 3) | (pixelRed >> 2);
pixelGreen = (pixelGreen << 2) | (pixelGreen >> 4);
pixelBlue = (pixelBlue << 3) | (pixelBlue >> 2);
}
// Write the colours away..
int destPixelOffset = (destY * ( int )m_header.m_width * 4) + (destX * 4);
m_pixelData[destPixelOffset + 0] = ( byte )pixelRed;
m_pixelData[destPixelOffset + 1] = ( byte )pixelGreen;
m_pixelData[destPixelOffset + 2] = ( byte )pixelBlue;
m_pixelData[destPixelOffset + 3] = ( byte )pixelAlpha;
}
}
}
}
