mirror of https://github.com/adamdruppe/arsd.git
dds image loader from ketmar
This commit is contained in:
Adam D. Ruppe
parent
766a252ef4
commit
b4cf5d0c46
|
|
@ -0,0 +1,797 @@
|
|||
// DDS decoders
|
||||
// Based on code from Nvidia's DDS example:
|
||||
// http://www.nvidia.com/object/dxtc_decompression_code.html
|
||||
//
|
||||
// Copyright (c) 2003 Randy Reddig
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without modification,
|
||||
// are permitted provided that the following conditions are met:
|
||||
//
|
||||
// Redistributions of source code must retain the above copyright notice, this list
|
||||
// of conditions and the following disclaimer.
|
||||
//
|
||||
// Redistributions in binary form must reproduce the above copyright notice, this
|
||||
// list of conditions and the following disclaimer in the documentation and/or
|
||||
// other materials provided with the distribution.
|
||||
//
|
||||
// Neither the names of the copyright holders nor the names of its contributors may
|
||||
// be used to endorse or promote products derived from this software without
|
||||
// specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
// ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
// D port and further changes by Ketmar // Invisible Vector
|
||||
module arsd.dds;
|
||||
|
||||
import arsd.color : Color, TrueColorImage;
|
||||
|
||||
|
||||
// ////////////////////////////////////////////////////////////////////////// //
|
||||
public bool ddsDetect (const(void)[] buf, int* width=null, int* height=null) nothrow @trusted @nogc {
|
||||
if (buf.length < 128) return false;
|
||||
auto data = cast(const(ubyte)[])buf;
|
||||
|
||||
uint getUInt (uint ofs) nothrow @trusted @nogc {
|
||||
if (ofs >= data.length) return uint.max;
|
||||
if (data.length-ofs < 4) return uint.max;
|
||||
return data.ptr[ofs]|(data.ptr[ofs+1]<<8)|(data.ptr[ofs+2]<<16)|(data.ptr[ofs+3]<<24);
|
||||
}
|
||||
|
||||
// signature
|
||||
if (data.ptr[0] != 'D' || data.ptr[1] != 'D' || data.ptr[2] != 'S' || data.ptr[3] != ' ') return false;
|
||||
// header size check
|
||||
if (getUInt(4) != 124) return false;
|
||||
|
||||
int w = getUInt(4*4);
|
||||
int h = getUInt(3*4);
|
||||
// arbitrary limits
|
||||
if (w < 1 || h < 1 || w > 65500 || h > 65500) return false;
|
||||
if (width !is null) *width = w;
|
||||
if (height !is null) *height = h;
|
||||
|
||||
// check pixel format
|
||||
if (getUInt(76) < 8) return false; // size
|
||||
immutable flags = getUInt(80);
|
||||
if (flags&DDS_FOURCC) {
|
||||
// DXTn
|
||||
if (data.ptr[84+0] != 'D' || data.ptr[84+1] != 'X' || data.ptr[84+2] != 'T') return false;
|
||||
if (data.ptr[84+3] < '1' || data.ptr[84+3] > '5') return false;
|
||||
} else if (flags == DDS_RGB || flags == DDS_RGBA) {
|
||||
immutable bitcount = getUInt(88);
|
||||
if (bitcount != 24 && bitcount != 32) return false;
|
||||
// ARGB8888
|
||||
//if (data.ptr[84+0] == 0 || data.ptr[84+1] == 0 || data.ptr[84+2] == 0 || data.ptr[84+3] == 0) return true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// ////////////////////////////////////////////////////////////////////////// //
|
||||
public TrueColorImage ddsLoadFromMemory (const(void)[] buf) {
|
||||
int w, h;
|
||||
if (!ddsDetect(buf, &w, &h)) throw new Exception("not a DDS image");
|
||||
|
||||
//FIXME: check for OOB access in decoders
|
||||
const(ddsBuffer_t)* dds = cast(const(ddsBuffer_t)*)buf.ptr;
|
||||
|
||||
auto tc = new TrueColorImage(w, h);
|
||||
scope(failure) delete tc;
|
||||
|
||||
if (!DDSDecompress(dds, tc.imageData.colors)) throw new Exception("invalid dds image");
|
||||
|
||||
return tc;
|
||||
}
|
||||
|
||||
|
||||
static import std.stdio;
|
||||
public TrueColorImage ddsLoadFromFile() (std.stdio.File fl) {
|
||||
import core.stdc.stdlib : malloc, free;
|
||||
auto fsize = fl.size-fl.tell;
|
||||
if (fsize < 128 || fsize > int.max/8) throw new Exception("invalid dds size");
|
||||
ddsBuffer_t* dds = cast(ddsBuffer_t*)malloc(cast(uint)fsize);
|
||||
if (dds is null) throw new Exception("out of memory");
|
||||
scope(exit) free(dds);
|
||||
ubyte[] lb = (cast(ubyte*)dds)[0..cast(uint)fsize];
|
||||
while (lb.length > 0) {
|
||||
auto rd = fl.rawRead(lb[]);
|
||||
if (rd.length < 1) throw new Exception("read error");
|
||||
lb = lb[rd.length..$];
|
||||
}
|
||||
return ddsLoadFromMemory((cast(ubyte*)dds)[0..cast(uint)fsize]);
|
||||
}
|
||||
|
||||
|
||||
static if (__traits(compiles, { import iv.vfs; })) {
|
||||
import iv.vfs;
|
||||
public TrueColorImage ddsLoadFromFile() (VFile fl) {
|
||||
import core.stdc.stdlib : malloc, free;
|
||||
auto fsize = fl.size-fl.tell;
|
||||
if (fsize < 128 || fsize > int.max/8) throw new Exception("invalid dds size");
|
||||
ddsBuffer_t* dds = cast(ddsBuffer_t*)malloc(cast(uint)fsize);
|
||||
if (dds is null) throw new Exception("out of memory");
|
||||
scope(exit) free(dds);
|
||||
ubyte[] lb = (cast(ubyte*)dds)[0..cast(uint)fsize];
|
||||
fl.rawReadExact(lb);
|
||||
return ddsLoadFromMemory(lb);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
// ////////////////////////////////////////////////////////////////////////// //
|
||||
private nothrow @trusted @nogc:
|
||||
|
||||
// dds definition
|
||||
enum DDSPixelFormat {
|
||||
Unknown,
|
||||
RGB888,
|
||||
ARGB8888,
|
||||
DXT1,
|
||||
DXT2,
|
||||
DXT3,
|
||||
DXT4,
|
||||
DXT5,
|
||||
}
|
||||
|
||||
|
||||
// 16bpp stuff
|
||||
enum DDS_LOW_5 = 0x001F;
|
||||
enum DDS_MID_6 = 0x07E0;
|
||||
enum DDS_HIGH_5 = 0xF800;
|
||||
enum DDS_MID_555 = 0x03E0;
|
||||
enum DDS_HI_555 = 0x7C00;
|
||||
|
||||
enum DDS_FOURCC = 0x00000004U;
|
||||
enum DDS_RGB = 0x00000040U;
|
||||
enum DDS_RGBA = 0x00000041U;
|
||||
enum DDS_DEPTH = 0x00800000U;
|
||||
|
||||
enum DDS_COMPLEX = 0x00000008U;
|
||||
enum DDS_CUBEMAP = 0x00000200U;
|
||||
enum DDS_VOLUME = 0x00200000U;
|
||||
|
||||
|
||||
// structures
|
||||
align(1) struct ddsColorKey_t {
|
||||
align(1):
|
||||
uint colorSpaceLowValue;
|
||||
uint colorSpaceHighValue;
|
||||
}
|
||||
|
||||
|
||||
align(1) struct ddsCaps_t {
|
||||
align(1):
|
||||
uint caps1;
|
||||
uint caps2;
|
||||
uint caps3;
|
||||
uint caps4;
|
||||
}
|
||||
|
||||
|
||||
align(1) struct ddsMultiSampleCaps_t {
|
||||
align(1):
|
||||
ushort flipMSTypes;
|
||||
ushort bltMSTypes;
|
||||
}
|
||||
|
||||
|
||||
align(1) struct ddsPixelFormat_t {
|
||||
align(1):
|
||||
uint size;
|
||||
uint flags;
|
||||
char[4] fourCC;
|
||||
union {
|
||||
uint rgbBitCount;
|
||||
uint yuvBitCount;
|
||||
uint zBufferBitDepth;
|
||||
uint alphaBitDepth;
|
||||
uint luminanceBitCount;
|
||||
uint bumpBitCount;
|
||||
uint privateFormatBitCount;
|
||||
}
|
||||
union {
|
||||
uint rBitMask;
|
||||
uint yBitMask;
|
||||
uint stencilBitDepth;
|
||||
uint luminanceBitMask;
|
||||
uint bumpDuBitMask;
|
||||
uint operations;
|
||||
}
|
||||
union {
|
||||
uint gBitMask;
|
||||
uint uBitMask;
|
||||
uint zBitMask;
|
||||
uint bumpDvBitMask;
|
||||
ddsMultiSampleCaps_t multiSampleCaps;
|
||||
}
|
||||
union {
|
||||
uint bBitMask;
|
||||
uint vBitMask;
|
||||
uint stencilBitMask;
|
||||
uint bumpLuminanceBitMask;
|
||||
}
|
||||
union {
|
||||
uint rgbAlphaBitMask;
|
||||
uint yuvAlphaBitMask;
|
||||
uint luminanceAlphaBitMask;
|
||||
uint rgbZBitMask;
|
||||
uint yuvZBitMask;
|
||||
}
|
||||
}
|
||||
//pragma(msg, ddsPixelFormat_t.sizeof);
|
||||
|
||||
|
||||
align(1) struct ddsBuffer_t {
|
||||
align(1):
|
||||
// magic: 'dds '
|
||||
char[4] magic;
|
||||
|
||||
// directdraw surface
|
||||
uint size;
|
||||
uint flags;
|
||||
uint height;
|
||||
uint width;
|
||||
union {
|
||||
int pitch;
|
||||
uint linearSize;
|
||||
}
|
||||
uint backBufferCount;
|
||||
union {
|
||||
uint mipMapCount;
|
||||
uint refreshRate;
|
||||
uint srcVBHandle;
|
||||
}
|
||||
uint alphaBitDepth;
|
||||
uint reserved;
|
||||
void* surface;
|
||||
union {
|
||||
ddsColorKey_t ckDestOverlay;
|
||||
uint emptyFaceColor;
|
||||
}
|
||||
ddsColorKey_t ckDestBlt;
|
||||
ddsColorKey_t ckSrcOverlay;
|
||||
ddsColorKey_t ckSrcBlt;
|
||||
union {
|
||||
ddsPixelFormat_t pixelFormat;
|
||||
uint fvf;
|
||||
}
|
||||
ddsCaps_t ddsCaps;
|
||||
uint textureStage;
|
||||
|
||||
// data (Varying size)
|
||||
ubyte[0] data;
|
||||
}
|
||||
//pragma(msg, ddsBuffer_t.sizeof);
|
||||
//pragma(msg, ddsBuffer_t.pixelFormat.offsetof+4*2);
|
||||
|
||||
|
||||
align(1) struct ddsColorBlock_t {
|
||||
align(1):
|
||||
ushort[2] colors;
|
||||
ubyte[4] row;
|
||||
}
|
||||
static assert(ddsColorBlock_t.sizeof == 8);
|
||||
|
||||
|
||||
align(1) struct ddsAlphaBlockExplicit_t {
|
||||
align(1):
|
||||
ushort[4] row;
|
||||
}
|
||||
static assert(ddsAlphaBlockExplicit_t.sizeof == 8);
|
||||
|
||||
|
||||
align(1) struct ddsAlphaBlock3BitLinear_t {
|
||||
align(1):
|
||||
ubyte alpha0;
|
||||
ubyte alpha1;
|
||||
ubyte[6] stuff;
|
||||
}
|
||||
static assert(ddsAlphaBlock3BitLinear_t.sizeof == 8);
|
||||
|
||||
|
||||
// ////////////////////////////////////////////////////////////////////////// //
|
||||
//public int DDSGetInfo( ddsBuffer_t *dds, int *width, int *height, DDSPixelFormat *pf );
|
||||
//public int DDSDecompress( ddsBuffer_t *dds, ubyte *pixels );
|
||||
|
||||
// extracts relevant info from a dds texture, returns `true` on success
|
||||
/*public*/ bool DDSGetInfo (const(ddsBuffer_t)* dds, int* width, int* height, DDSPixelFormat* pf) {
|
||||
// dummy test
|
||||
if (dds is null) return false;
|
||||
|
||||
// test dds header
|
||||
if (dds.magic != "DDS ") return false;
|
||||
if (DDSLittleLong(dds.size) != 124) return false;
|
||||
// arbitrary limits
|
||||
if (DDSLittleLong(dds.width) < 1 || DDSLittleLong(dds.width) > 65535) return false;
|
||||
if (DDSLittleLong(dds.height) < 1 || DDSLittleLong(dds.height) > 65535) return false;
|
||||
|
||||
// extract width and height
|
||||
if (width !is null) *width = DDSLittleLong(dds.width);
|
||||
if (height !is null) *height = DDSLittleLong(dds.height);
|
||||
|
||||
// get pixel format
|
||||
DDSDecodePixelFormat(dds, pf);
|
||||
|
||||
// return ok
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// decompresses a dds texture into an rgba image buffer, returns 0 on success
|
||||
/*public*/ bool DDSDecompress (const(ddsBuffer_t)* dds, Color[] pixels) {
|
||||
int width, height;
|
||||
DDSPixelFormat pf;
|
||||
|
||||
// get dds info
|
||||
if (!DDSGetInfo(dds, &width, &height, &pf)) return false;
|
||||
// arbitrary limits
|
||||
if (DDSLittleLong(dds.width) < 1 || DDSLittleLong(dds.width) > 65535) return false;
|
||||
if (DDSLittleLong(dds.height) < 1 || DDSLittleLong(dds.height) > 65535) return false;
|
||||
if (pixels.length < width*height) return false;
|
||||
|
||||
// decompress
|
||||
final switch (pf) {
|
||||
// FIXME: support other [a]rgb formats
|
||||
case DDSPixelFormat.RGB888: return DDSDecompressRGB888(dds, width, height, pixels.ptr);
|
||||
case DDSPixelFormat.ARGB8888: return DDSDecompressARGB8888(dds, width, height, pixels.ptr);
|
||||
case DDSPixelFormat.DXT1: return DDSDecompressDXT1(dds, width, height, pixels.ptr);
|
||||
case DDSPixelFormat.DXT2: return DDSDecompressDXT2(dds, width, height, pixels.ptr);
|
||||
case DDSPixelFormat.DXT3: return DDSDecompressDXT3(dds, width, height, pixels.ptr);
|
||||
case DDSPixelFormat.DXT4: return DDSDecompressDXT4(dds, width, height, pixels.ptr);
|
||||
case DDSPixelFormat.DXT5: return DDSDecompressDXT5(dds, width, height, pixels.ptr);
|
||||
case DDSPixelFormat.Unknown: break;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
// ////////////////////////////////////////////////////////////////////////// //
|
||||
private:
|
||||
|
||||
version(BigEndian) {
|
||||
int DDSLittleLong (int src) pure nothrow @safe @nogc {
|
||||
pragma(inline, true);
|
||||
return
|
||||
((src&0xFF000000)>>24)|
|
||||
((src&0x00FF0000)>>8)|
|
||||
((src&0x0000FF00)<<8)|
|
||||
((src&0x000000FF)<<24);
|
||||
}
|
||||
short DDSLittleShort (short src) pure nothrow @safe @nogc {
|
||||
pragma(inline, true);
|
||||
return cast(short)(((src&0xFF00)>>8)|((src&0x00FF)<<8));
|
||||
}
|
||||
} else {
|
||||
// little endian
|
||||
int DDSLittleLong (int src) pure nothrow @safe @nogc { pragma(inline, true); return src; }
|
||||
short DDSLittleShort (short src) pure nothrow @safe @nogc { pragma(inline, true); return src; }
|
||||
}
|
||||
|
||||
|
||||
// determines which pixel format the dds texture is in
|
||||
private void DDSDecodePixelFormat (const(ddsBuffer_t)* dds, DDSPixelFormat* pf) {
|
||||
// dummy check
|
||||
if (dds is null || pf is null) return;
|
||||
*pf = DDSPixelFormat.Unknown;
|
||||
|
||||
if (dds.pixelFormat.size < 8) return;
|
||||
|
||||
if (dds.pixelFormat.flags&DDS_FOURCC) {
|
||||
// DXTn
|
||||
if (dds.pixelFormat.fourCC == "DXT1") *pf = DDSPixelFormat.DXT1;
|
||||
else if (dds.pixelFormat.fourCC == "DXT2") *pf = DDSPixelFormat.DXT2;
|
||||
else if (dds.pixelFormat.fourCC == "DXT3") *pf = DDSPixelFormat.DXT3;
|
||||
else if (dds.pixelFormat.fourCC == "DXT4") *pf = DDSPixelFormat.DXT4;
|
||||
else if (dds.pixelFormat.fourCC == "DXT5") *pf = DDSPixelFormat.DXT5;
|
||||
else return;
|
||||
} else if (dds.pixelFormat.flags == DDS_RGB || dds.pixelFormat.flags == DDS_RGBA) {
|
||||
//immutable bitcount = getUInt(88);
|
||||
if (dds.pixelFormat.rgbBitCount == 24) *pf = DDSPixelFormat.RGB888;
|
||||
else if (dds.pixelFormat.rgbBitCount == 32) *pf = DDSPixelFormat.ARGB8888;
|
||||
else return;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// extracts colors from a dds color block
|
||||
private void DDSGetColorBlockColors (const(ddsColorBlock_t)* block, Color* colors) {
|
||||
ushort word;
|
||||
|
||||
// color 0
|
||||
word = DDSLittleShort(block.colors.ptr[0]);
|
||||
colors[0].a = 0xff;
|
||||
|
||||
// extract rgb bits
|
||||
colors[0].b = cast(ubyte)word;
|
||||
colors[0].b <<= 3;
|
||||
colors[0].b |= (colors[0].b>>5);
|
||||
word >>= 5;
|
||||
colors[0].g = cast(ubyte)word;
|
||||
colors[0].g <<= 2;
|
||||
colors[0].g |= (colors[0].g>>5);
|
||||
word >>= 6;
|
||||
colors[0].r = cast(ubyte)word;
|
||||
colors[0].r <<= 3;
|
||||
colors[0].r |= (colors[0].r>>5);
|
||||
|
||||
// same for color 1
|
||||
word = DDSLittleShort(block.colors.ptr[1]);
|
||||
colors[1].a = 0xff;
|
||||
|
||||
// extract rgb bits
|
||||
colors[1].b = cast(ubyte)word;
|
||||
colors[1].b <<= 3;
|
||||
colors[1].b |= (colors[1].b>>5);
|
||||
word >>= 5;
|
||||
colors[1].g = cast(ubyte)word;
|
||||
colors[1].g <<= 2;
|
||||
colors[1].g |= (colors[1].g>>5);
|
||||
word >>= 6;
|
||||
colors[1].r = cast(ubyte)word;
|
||||
colors[1].r <<= 3;
|
||||
colors[1].r |= (colors[1].r>>5);
|
||||
|
||||
// use this for all but the super-freak math method
|
||||
if (block.colors.ptr[0] > block.colors.ptr[1]) {
|
||||
/* four-color block: derive the other two colors.
|
||||
00 = color 0, 01 = color 1, 10 = color 2, 11 = color 3
|
||||
these two bit codes correspond to the 2-bit fields
|
||||
stored in the 64-bit block. */
|
||||
word = (cast(ushort)colors[0].r*2+cast(ushort)colors[1].r)/3;
|
||||
// no +1 for rounding
|
||||
// as bits have been shifted to 888
|
||||
colors[2].r = cast(ubyte) word;
|
||||
word = (cast(ushort)colors[0].g*2+cast(ushort)colors[1].g)/3;
|
||||
colors[2].g = cast(ubyte) word;
|
||||
word = (cast(ushort)colors[0].b*2+cast(ushort)colors[1].b)/3;
|
||||
colors[2].b = cast(ubyte)word;
|
||||
colors[2].a = 0xff;
|
||||
|
||||
word = (cast(ushort)colors[0].r+cast(ushort)colors[1].r*2)/3;
|
||||
colors[3].r = cast(ubyte)word;
|
||||
word = (cast(ushort)colors[0].g+cast(ushort)colors[1].g*2)/3;
|
||||
colors[3].g = cast(ubyte)word;
|
||||
word = (cast(ushort)colors[0].b+cast(ushort)colors[1].b*2)/3;
|
||||
colors[3].b = cast(ubyte)word;
|
||||
colors[3].a = 0xff;
|
||||
} else {
|
||||
/* three-color block: derive the other color.
|
||||
00 = color 0, 01 = color 1, 10 = color 2,
|
||||
11 = transparent.
|
||||
These two bit codes correspond to the 2-bit fields
|
||||
stored in the 64-bit block */
|
||||
word = (cast(ushort)colors[0].r+cast(ushort)colors[1].r)/2;
|
||||
colors[2].r = cast(ubyte)word;
|
||||
word = (cast(ushort)colors[0].g+cast(ushort)colors[1].g)/2;
|
||||
colors[2].g = cast(ubyte)word;
|
||||
word = (cast(ushort)colors[0].b+cast(ushort)colors[1].b)/2;
|
||||
colors[2].b = cast(ubyte)word;
|
||||
colors[2].a = 0xff;
|
||||
|
||||
// random color to indicate alpha
|
||||
colors[3].r = 0x00;
|
||||
colors[3].g = 0xff;
|
||||
colors[3].b = 0xff;
|
||||
colors[3].a = 0x00;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//decodes a dds color block
|
||||
//FIXME: make endian-safe
|
||||
private void DDSDecodeColorBlock (uint* pixel, const(ddsColorBlock_t)* block, int width, const(Color)* colors) {
|
||||
int r, n;
|
||||
uint bits;
|
||||
static immutable uint[4] masks = [ 3, 12, 3<<4, 3<<6 ]; // bit masks = 00000011, 00001100, 00110000, 11000000
|
||||
static immutable ubyte[4] shift = [ 0, 2, 4, 6 ];
|
||||
// r steps through lines in y
|
||||
// no width * 4 as unsigned int ptr inc will * 4
|
||||
for (r = 0; r < 4; ++r, pixel += width-4) {
|
||||
// width * 4 bytes per pixel per line, each j dxtc row is 4 lines of pixels
|
||||
// n steps through pixels
|
||||
for (n = 0; n < 4; ++n) {
|
||||
bits = block.row.ptr[r]&masks.ptr[n];
|
||||
bits >>= shift.ptr[n];
|
||||
switch (bits) {
|
||||
case 0: *pixel++ = colors[0].asUint; break;
|
||||
case 1: *pixel++ = colors[1].asUint; break;
|
||||
case 2: *pixel++ = colors[2].asUint; break;
|
||||
case 3: *pixel++ = colors[3].asUint; break;
|
||||
default: ++pixel; break; // invalid
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// decodes a dds explicit alpha block
|
||||
//FIXME: endianness
|
||||
private void DDSDecodeAlphaExplicit (uint* pixel, const(ddsAlphaBlockExplicit_t)* alphaBlock, int width, uint alphaZero) {
|
||||
int row, pix;
|
||||
ushort word;
|
||||
Color color;
|
||||
|
||||
// clear color
|
||||
color.r = 0;
|
||||
color.g = 0;
|
||||
color.b = 0;
|
||||
|
||||
// walk rows
|
||||
for (row = 0; row < 4; ++row, pixel += width-4) {
|
||||
word = DDSLittleShort(alphaBlock.row.ptr[row]);
|
||||
// walk pixels
|
||||
for (pix = 0; pix < 4; ++pix) {
|
||||
// zero the alpha bits of image pixel
|
||||
*pixel &= alphaZero;
|
||||
color.a = word&0x000F;
|
||||
color.a = cast(ubyte)(color.a|(color.a<<4));
|
||||
*pixel |= *(cast(const(uint)*)&color);
|
||||
word >>= 4; // move next bits to lowest 4
|
||||
++pixel; // move to next pixel in the row
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// decodes interpolated alpha block
|
||||
private void DDSDecodeAlpha3BitLinear (uint* pixel, const(ddsAlphaBlock3BitLinear_t)* alphaBlock, int width, uint alphaZero) {
|
||||
int row, pix;
|
||||
uint stuff;
|
||||
ubyte[4][4] bits;
|
||||
ushort[8] alphas;
|
||||
Color[4][4] aColors;
|
||||
|
||||
// get initial alphas
|
||||
alphas.ptr[0] = alphaBlock.alpha0;
|
||||
alphas.ptr[1] = alphaBlock.alpha1;
|
||||
|
||||
if (alphas.ptr[0] > alphas.ptr[1]) {
|
||||
// 8-alpha block
|
||||
// 000 = alpha_0, 001 = alpha_1, others are interpolated
|
||||
alphas.ptr[2] = (6*alphas.ptr[0]+alphas.ptr[1])/7; // bit code 010
|
||||
alphas.ptr[3] = (5*alphas.ptr[0]+2*alphas.ptr[1])/7; // bit code 011
|
||||
alphas.ptr[4] = (4*alphas.ptr[0]+3*alphas.ptr[1])/7; // bit code 100
|
||||
alphas.ptr[5] = (3*alphas.ptr[0]+4*alphas.ptr[1])/7; // bit code 101
|
||||
alphas.ptr[6] = (2*alphas.ptr[0]+5*alphas.ptr[1])/7; // bit code 110
|
||||
alphas.ptr[7] = (alphas.ptr[0]+6*alphas.ptr[1])/7; // bit code 111
|
||||
} else {
|
||||
// 6-alpha block
|
||||
// 000 = alpha_0, 001 = alpha_1, others are interpolated
|
||||
alphas.ptr[2] = (4*alphas.ptr[0]+alphas.ptr[1])/5; // bit code 010
|
||||
alphas.ptr[3] = (3*alphas.ptr[0]+2*alphas.ptr[1])/5; // bit code 011
|
||||
alphas.ptr[4] = (2*alphas.ptr[0]+3*alphas.ptr[1])/5; // bit code 100
|
||||
alphas.ptr[5] = (alphas.ptr[0]+4*alphas.ptr[1])/5; // bit code 101
|
||||
alphas.ptr[6] = 0; // bit code 110
|
||||
alphas.ptr[7] = 255; // bit code 111
|
||||
}
|
||||
|
||||
// decode 3-bit fields into array of 16 bytes with same value
|
||||
|
||||
// first two rows of 4 pixels each
|
||||
stuff = *(cast(const(uint)*)&(alphaBlock.stuff.ptr[0]));
|
||||
|
||||
bits.ptr[0].ptr[0] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[0].ptr[1] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[0].ptr[2] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[0].ptr[3] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[1].ptr[0] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[1].ptr[1] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[1].ptr[2] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[1].ptr[3] = cast(ubyte)(stuff&0x00000007);
|
||||
|
||||
// last two rows
|
||||
stuff = *(cast(const(uint)*)&(alphaBlock.stuff.ptr[3])); // last 3 bytes
|
||||
|
||||
bits.ptr[2].ptr[0] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[2].ptr[1] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[2].ptr[2] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[2].ptr[3] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[3].ptr[0] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[3].ptr[1] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[3].ptr[2] = cast(ubyte)(stuff&0x00000007);
|
||||
stuff >>= 3;
|
||||
bits.ptr[3].ptr[3] = cast(ubyte)(stuff&0x00000007);
|
||||
|
||||
// decode the codes into alpha values
|
||||
for (row = 0; row < 4; ++row) {
|
||||
for (pix = 0; pix < 4; ++pix) {
|
||||
aColors.ptr[row].ptr[pix].r = 0;
|
||||
aColors.ptr[row].ptr[pix].g = 0;
|
||||
aColors.ptr[row].ptr[pix].b = 0;
|
||||
aColors.ptr[row].ptr[pix].a = cast(ubyte)alphas.ptr[bits.ptr[row].ptr[pix]];
|
||||
}
|
||||
}
|
||||
|
||||
// write out alpha values to the image bits
|
||||
for (row = 0; row < 4; ++row, pixel += width-4) {
|
||||
for (pix = 0; pix < 4; ++pix) {
|
||||
// zero the alpha bits of image pixel
|
||||
*pixel &= alphaZero;
|
||||
// or the bits into the prev. nulled alpha
|
||||
*pixel |= *(cast(const(uint)*)&(aColors.ptr[row].ptr[pix]));
|
||||
++pixel;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// decompresses a dxt1 format texture
|
||||
private bool DDSDecompressDXT1 (const(ddsBuffer_t)* dds, int width, int height, Color* pixels) {
|
||||
Color[4] colors;
|
||||
immutable int xBlocks = width/4;
|
||||
immutable int yBlocks = height/4;
|
||||
// 8 bytes per block
|
||||
auto block = cast(const(ddsColorBlock_t)*)dds.data.ptr;
|
||||
foreach (immutable y; 0..yBlocks) {
|
||||
foreach (immutable x; 0..xBlocks) {
|
||||
DDSGetColorBlockColors(block, colors.ptr);
|
||||
auto pixel = cast(uint*)(pixels+x*4+(y*4)*width);
|
||||
DDSDecodeColorBlock(pixel, block, width, colors.ptr);
|
||||
++block;
|
||||
}
|
||||
}
|
||||
// return ok
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// decompresses a dxt3 format texture
|
||||
private bool DDSDecompressDXT3 (const(ddsBuffer_t)* dds, int width, int height, Color* pixels) {
|
||||
Color[4] colors;
|
||||
|
||||
// setup
|
||||
immutable int xBlocks = width/4;
|
||||
immutable int yBlocks = height/4;
|
||||
|
||||
// create zero alpha
|
||||
colors.ptr[0].a = 0;
|
||||
colors.ptr[0].r = 0xFF;
|
||||
colors.ptr[0].g = 0xFF;
|
||||
colors.ptr[0].b = 0xFF;
|
||||
immutable uint alphaZero = colors.ptr[0].asUint;
|
||||
|
||||
// 8 bytes per block, 1 block for alpha, 1 block for color
|
||||
auto block = cast(const(ddsColorBlock_t)*)dds.data.ptr;
|
||||
foreach (immutable y; 0..yBlocks) {
|
||||
foreach (immutable x; 0..xBlocks) {
|
||||
// get alpha block
|
||||
auto alphaBlock = cast(const(ddsAlphaBlockExplicit_t)*)block++;
|
||||
// get color block
|
||||
DDSGetColorBlockColors(block, colors.ptr);
|
||||
// decode color block
|
||||
auto pixel = cast(uint*)(pixels+x*4+(y*4)*width);
|
||||
DDSDecodeColorBlock(pixel, block, width, colors.ptr);
|
||||
// overwrite alpha bits with alpha block
|
||||
DDSDecodeAlphaExplicit(pixel, alphaBlock, width, alphaZero);
|
||||
++block;
|
||||
}
|
||||
}
|
||||
|
||||
// return ok
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// decompresses a dxt5 format texture
|
||||
private bool DDSDecompressDXT5 (const(ddsBuffer_t)* dds, int width, int height, Color* pixels) {
|
||||
Color[4] colors;
|
||||
|
||||
// setup
|
||||
immutable int xBlocks = width/4;
|
||||
immutable int yBlocks = height/4;
|
||||
|
||||
// create zero alpha
|
||||
colors.ptr[0].a = 0;
|
||||
colors.ptr[0].r = 0xFF;
|
||||
colors.ptr[0].g = 0xFF;
|
||||
colors.ptr[0].b = 0xFF;
|
||||
immutable uint alphaZero = colors.ptr[0].asUint;
|
||||
|
||||
// 8 bytes per block, 1 block for alpha, 1 block for color
|
||||
auto block = cast(const(ddsColorBlock_t)*)dds.data.ptr;
|
||||
foreach (immutable y; 0..yBlocks) {
|
||||
//block = cast(ddsColorBlock_t*)(dds.data.ptr+y*xBlocks*16);
|
||||
foreach (immutable x; 0..xBlocks) {
|
||||
// get alpha block
|
||||
auto alphaBlock = cast(const(ddsAlphaBlock3BitLinear_t)*)block++;
|
||||
// get color block
|
||||
DDSGetColorBlockColors(block, colors.ptr);
|
||||
// decode color block
|
||||
auto pixel = cast(uint*)(pixels+x*4+(y*4)*width);
|
||||
DDSDecodeColorBlock(pixel, block, width, colors.ptr);
|
||||
// overwrite alpha bits with alpha block
|
||||
DDSDecodeAlpha3BitLinear(pixel, alphaBlock, width, alphaZero);
|
||||
++block;
|
||||
}
|
||||
}
|
||||
|
||||
// return ok
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
private void unmultiply (Color[] pixels) {
|
||||
// premultiplied alpha
|
||||
foreach (ref Color clr; pixels) {
|
||||
if (clr.a != 0) {
|
||||
clr.r = Color.clampToByte(clr.r*255/clr.a);
|
||||
clr.g = Color.clampToByte(clr.g*255/clr.a);
|
||||
clr.b = Color.clampToByte(clr.b*255/clr.a);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// decompresses a dxt2 format texture (FIXME: un-premultiply alpha)
|
||||
private bool DDSDecompressDXT2 (const(ddsBuffer_t)* dds, int width, int height, Color* pixels) {
|
||||
// decompress dxt3 first
|
||||
if (!DDSDecompressDXT3(dds, width, height, pixels)) return false;
|
||||
//FIXME: is un-premultiply correct?
|
||||
unmultiply(pixels[0..width*height]);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// decompresses a dxt4 format texture (FIXME: un-premultiply alpha)
|
||||
private bool DDSDecompressDXT4 (const(ddsBuffer_t)* dds, int width, int height, Color* pixels) {
|
||||
// decompress dxt5 first
|
||||
if (!DDSDecompressDXT5(dds, width, height, pixels)) return false;
|
||||
//FIXME: is un-premultiply correct?
|
||||
unmultiply(pixels[0..width*height]);
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// decompresses an argb 8888 format texture
|
||||
private bool DDSDecompressARGB8888 (const(ddsBuffer_t)* dds, int width, int height, Color* pixels) {
|
||||
auto zin = cast(const(Color)*)dds.data.ptr;
|
||||
//pixels[0..width*height] = zin[0..width*height];
|
||||
foreach (immutable idx; 0..width*height) {
|
||||
pixels.r = zin.b;
|
||||
pixels.g = zin.g;
|
||||
pixels.b = zin.r;
|
||||
pixels.a = zin.a;
|
||||
++pixels;
|
||||
++zin;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
// decompresses an rgb 888 format texture
|
||||
private bool DDSDecompressRGB888 (const(ddsBuffer_t)* dds, int width, int height, Color* pixels) {
|
||||
auto zin = cast(const(ubyte)*)dds.data.ptr;
|
||||
//pixels[0..width*height] = zin[0..width*height];
|
||||
foreach (immutable idx; 0..width*height) {
|
||||
pixels.b = *zin++;
|
||||
pixels.g = *zin++;
|
||||
pixels.r = *zin++;
|
||||
pixels.a = 255;
|
||||
++pixels;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
9
image.d
9
image.d
|
|
@ -7,6 +7,7 @@ public import arsd.jpeg;
|
|||
public import arsd.bmp;
|
||||
public import arsd.targa;
|
||||
public import arsd.pcx;
|
||||
public import arsd.dds;
|
||||
|
||||
static if (__traits(compiles, { import iv.vfs; })) enum ArsdImageHasIVVFS = true; else enum ArsdImageHasIVVFS = false;
|
||||
|
||||
|
|
@ -32,6 +33,7 @@ enum ImageFileFormat {
|
|||
Tga, ///
|
||||
Gif, /// we can't load it yet, but we can at least detect it
|
||||
Pcx, /// can load 8BPP and 24BPP pcx images
|
||||
Dds, /// can load ARGB8888, DXT1, DXT3, DXT5 dds images (without mipmaps)
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -52,6 +54,7 @@ public ImageFileFormat guessImageFormatFromExtension (const(char)[] filename) {
|
|||
if (strEquCI(ext, "gif")) return ImageFileFormat.Gif;
|
||||
if (strEquCI(ext, "tga")) return ImageFileFormat.Tga;
|
||||
if (strEquCI(ext, "pcx")) return ImageFileFormat.Pcx;
|
||||
if (strEquCI(ext, "dds")) return ImageFileFormat.Dds;
|
||||
return ImageFileFormat.Unknown;
|
||||
}
|
||||
|
||||
|
|
@ -79,6 +82,8 @@ public ImageFileFormat guessImageFormatFromMemory (const(void)[] membuf) {
|
|||
{
|
||||
return ImageFileFormat.Gif;
|
||||
}
|
||||
// dds
|
||||
if (ddsDetect(membuf)) return ImageFileFormat.Dds;
|
||||
// jpg
|
||||
try {
|
||||
int width, height, components;
|
||||
|
|
@ -224,6 +229,9 @@ public MemoryImage loadImageFromFile(T:const(char)[]) (T filename) {
|
|||
case ImageFileFormat.Gif: throw new Exception("arsd has no GIF loader yet");
|
||||
case ImageFileFormat.Tga: return loadTga(filename);
|
||||
case ImageFileFormat.Pcx: return loadPcx(filename);
|
||||
case ImageFileFormat.Dds:
|
||||
static if (ArsdImageHasIVVFS) auto fl = VFile(filename); else { import std.stdio; auto fl = File(filename); }
|
||||
return ddsLoadFromFile(fl);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -239,6 +247,7 @@ public MemoryImage loadImageFromMemory (const(void)[] membuf) {
|
|||
case ImageFileFormat.Gif: throw new Exception("arsd has no GIF loader yet");
|
||||
case ImageFileFormat.Tga: return loadTgaMem(membuf);
|
||||
case ImageFileFormat.Pcx: return loadPcxMem(membuf);
|
||||
case ImageFileFormat.Dds: return ddsLoadFromMemory(membuf);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
6
targa.d
6
targa.d
|
|
@ -394,9 +394,9 @@ private MemoryImage loadTgaImpl(ST) (auto ref ST fl, const(char)[] filename) {
|
|||
// premultiplied alpha
|
||||
foreach (ref Color clr; tcimg.imageData.colors) {
|
||||
if (clr.a != 0) {
|
||||
clr.r = cast(ubyte)(clr.r*255/clr.a);
|
||||
clr.g = cast(ubyte)(clr.g*255/clr.a);
|
||||
clr.b = cast(ubyte)(clr.b*255/clr.a);
|
||||
clr.r = Color.clampToByte(clr.r*255/clr.a);
|
||||
clr.g = Color.clampToByte(clr.g*255/clr.a);
|
||||
clr.b = Color.clampToByte(clr.b*255/clr.a);
|
||||
}
|
||||
}
|
||||
} else if (ext.attrType != 3) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue