forks
/
arsd
mirror of https://github.com/adamdruppe/arsd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
arsd/targa.d

697 lines
22 KiB
D
Raw Permalink Blame History

//ketmar: Adam didn't wrote this, don't blame him!
module arsd.targa;
import arsd.color;
import std.stdio : File; // sorry
static if (__traits(compiles, { import iv.vfs; })) enum ArsdTargaHasIVVFS = true; else enum ArsdTargaHasIVVFS = false;
static if (ArsdTargaHasIVVFS) import iv.vfs;
// ////////////////////////////////////////////////////////////////////////// //
public MemoryImage loadTgaMem (const(void)[] buf, const(char)[] filename=null) {
static struct MemRO {
const(ubyte)[] data;
long pos;
this (const(void)[] abuf) { data = cast(const(ubyte)[])abuf; }
@property long tell () { return pos; }
@property long size () { return data.length; }
void seek (long offset, int whence=Seek.Set) {
switch (whence) {
case Seek.Set:
if (offset < 0 || offset > data.length) throw new Exception("invalid offset");
pos = offset;
break;
case Seek.Cur:
if (offset < -pos || offset > data.length-pos) throw new Exception("invalid offset");
pos += offset;
break;
case Seek.End:
pos = data.length+offset;
if (pos < 0 || pos > data.length) throw new Exception("invalid offset");
break;
default:
throw new Exception("invalid offset origin");
}
}
ptrdiff_t read (void* buf, size_t count) @system {
if (pos >= data.length) return 0;
if (count > 0) {
import core.stdc.string : memcpy;
long rlen = data.length-pos;
if (rlen >= count) rlen = count;
assert(rlen != 0);
memcpy(buf, data.ptr+pos, cast(size_t)rlen);
pos += rlen;
return cast(ptrdiff_t)rlen;
} else {
return 0;
}
}
}
auto rd = MemRO(buf);
return loadTga(rd, filename);
}
static if (ArsdTargaHasIVVFS) public MemoryImage loadTga (VFile fl) { return loadTgaImpl(fl, fl.name); }
public MemoryImage loadTga (File fl) { return loadTgaImpl(fl, fl.name); }
public MemoryImage loadTga(T:const(char)[]) (T fname) {
static if (is(T == typeof(null))) {
throw new Exception("cannot load nameless tga");
} else {
static if (ArsdTargaHasIVVFS) {
return loadTga(VFile(fname));
} else static if (is(T == string)) {
return loadTga(File(fname), fname);
} else {
return loadTga(File(fname.idup), fname);
}
}
}
// pass filename to ease detection
// hack around "has scoped destruction, cannot build closure"
public MemoryImage loadTga(ST) (auto ref ST fl, const(char)[] filename=null) if (isReadableStream!ST && isSeekableStream!ST) { return loadTgaImpl(fl, filename); }
private MemoryImage loadTgaImpl(ST) (auto ref ST fl, const(char)[] filename) {
enum TGAFILESIGNATURE = "TRUEVISION-XFILE.\x00";
static immutable ubyte[32] cmap16 = [0,8,16,25,33,41,49,58,66,74,82,90,99,107,115,123,132,140,148,156,165,173,181,189,197,206,214,222,230,239,247,255];
static struct Header {
ubyte idsize;
ubyte cmapType;
ubyte imgType;
ushort cmapFirstIdx;
ushort cmapSize;
ubyte cmapElementSize;
ushort originX;
ushort originY;
ushort width;
ushort height;
ubyte bpp;
ubyte imgdsc;
@property bool zeroBits () const pure nothrow @safe @nogc { return ((imgdsc&0xc0) == 0); }
@property bool xflip () const pure nothrow @safe @nogc { return ((imgdsc&0b010000) != 0); }
@property bool yflip () const pure nothrow @safe @nogc { return ((imgdsc&0b100000) == 0); }
}
static struct ExtFooter {
uint extofs;
uint devdirofs;
char[18] sign=0;
}
static struct Extension {
ushort size;
char[41] author=0;
char[324] comments=0;
ushort month, day, year;
ushort hour, minute, second;
char[41] jid=0;
ushort jhours, jmins, jsecs;
char[41] producer=0;
ushort prodVer;
ubyte prodSubVer;
ubyte keyR, keyG, keyB, keyZero;
ushort pixratioN, pixratioD;
ushort gammaN, gammaD;
uint ccofs;
uint wtfofs;
uint scanlineofs;
ubyte attrType;
}
ExtFooter extfooter;
uint rleBC, rleDC;
ubyte[4] rleLast;
Color[256] cmap;
void readPixel(bool asRLE, uint bytesPerPixel) (ubyte[] pixel, scope ubyte delegate () readByte) {
static if (asRLE) {
if (rleDC > 0) {
// still counting
static if (bytesPerPixel == 1) pixel.ptr[0] = rleLast.ptr[0];
else pixel.ptr[0..bytesPerPixel] = rleLast.ptr[0..bytesPerPixel];
--rleDC;
return;
}
if (rleBC > 0) {
--rleBC;
} else {
ubyte b = readByte();
if (b&0x80) rleDC = (b&0x7f); else rleBC = (b&0x7f);
}
foreach (immutable idx; 0..bytesPerPixel) rleLast.ptr[idx] = pixel.ptr[idx] = readByte();
} else {
foreach (immutable idx; 0..bytesPerPixel) pixel.ptr[idx] = readByte();
}
}
// 8 bit color-mapped row
Color readColorCM8(bool asRLE) (scope ubyte delegate () readByte) {
ubyte[1] pixel = void;
readPixel!(asRLE, 1)(pixel[], readByte);
auto cmp = cast(const(ubyte)*)(cmap.ptr+pixel.ptr[0]);
return Color(cmp[0], cmp[1], cmp[2]);
}
// 8 bit greyscale
Color readColorBM8(bool asRLE) (scope ubyte delegate () readByte) {
ubyte[1] pixel = void;
readPixel!(asRLE, 1)(pixel[], readByte);
return Color(pixel.ptr[0], pixel.ptr[0], pixel.ptr[0]);
}
// 16 bit greyscale
Color readColorBM16(bool asRLE) (scope ubyte delegate () readByte) {
ubyte[2] pixel = void;
readPixel!(asRLE, 2)(pixel[], readByte);
immutable ubyte v = cast(ubyte)((pixel.ptr[0]|(pixel.ptr[1]<<8))>>8);
return Color(v, v, v);
}
// 16 bit
Color readColor16(bool asRLE) (scope ubyte delegate () readByte) {
ubyte[2] pixel = void;
readPixel!(asRLE, 2)(pixel[], readByte);
immutable v = pixel.ptr[0]+(pixel.ptr[1]<<8);
return Color(cmap16.ptr[(v>>10)&0x1f], cmap16.ptr[(v>>5)&0x1f], cmap16.ptr[v&0x1f]);
}
// 24 bit or 32 bit
Color readColorTrue(bool asRLE, uint bytesPerPixel) (scope ubyte delegate () readByte) {
ubyte[bytesPerPixel] pixel = void;
readPixel!(asRLE, bytesPerPixel)(pixel[], readByte);
static if (bytesPerPixel == 4) {
return Color(pixel.ptr[2], pixel.ptr[1], pixel.ptr[0], pixel.ptr[3]);
} else {
return Color(pixel.ptr[2], pixel.ptr[1], pixel.ptr[0]);
}
}
bool isGoodExtension (const(char)[] filename) {
if (filename.length >= 4) {
// try extension
auto ext = filename[$-4..$];
if (ext[0] == '.' && (ext[1] == 'T' || ext[1] == 't') && (ext[2] == 'G' || ext[2] == 'g') && (ext[3] == 'A' || ext[3] == 'a')) return true;
}
// try signature
return false;
}
bool detect(ST) (auto ref ST fl, const(char)[] filename) if (isReadableStream!ST && isSeekableStream!ST) {
bool goodext = false;
if (fl.size < 45) return false; // minimal 1x1 tga
if (filename.length) { goodext = isGoodExtension(filename); if (!goodext) return false; }
// try footer
fl.seek(-(4*2+18), Seek.End);
extfooter.extofs = fl.readNum!uint;
extfooter.devdirofs = fl.readNum!uint;
fl.rawReadExact(extfooter.sign[]);
if (extfooter.sign != TGAFILESIGNATURE) {
//if (!goodext) return false;
extfooter = extfooter.init;
return true; // alas, footer is optional
}
return true;
}
if (!detect(fl, filename)) throw new Exception("not a TGA");
fl.seek(0);
Header hdr;
fl.readStruct(hdr);
// parse header
// arbitrary size limits
if (hdr.width == 0 || hdr.width > 32000) throw new Exception("invalid tga width");
if (hdr.height == 0 || hdr.height > 32000) throw new Exception("invalid tga height");
switch (hdr.bpp) {
case 1: case 2: case 4: case 8: case 15: case 16: case 24: case 32: break;
default: throw new Exception("invalid tga bpp");
}
uint bytesPerPixel = ((hdr.bpp)>>3);
if (bytesPerPixel == 0 || bytesPerPixel > 4) throw new Exception("invalid tga pixel size");
bool loadCM = false;
// get the row reading function
ubyte readByte () { ubyte b; fl.rawReadExact((&b)[0..1]); return b; }
scope Color delegate (scope ubyte delegate () readByte) readColor;
switch (hdr.imgType) {
case 2: // true color, no rle
switch (bytesPerPixel) {
case 2: readColor = &readColor16!false; break;
case 3: readColor = &readColorTrue!(false, 3); break;
case 4: readColor = &readColorTrue!(false, 4); break;
default: throw new Exception("invalid tga pixel size");
}
break;
case 10: // true color, rle
switch (bytesPerPixel) {
case 2: readColor = &readColor16!true; break;
case 3: readColor = &readColorTrue!(true, 3); break;
case 4: readColor = &readColorTrue!(true, 4); break;
default: throw new Exception("invalid tga pixel size");
}
break;
case 3: // black&white, no rle
switch (bytesPerPixel) {
case 1: readColor = &readColorBM8!false; break;
case 2: readColor = &readColorBM16!false; break;
default: throw new Exception("invalid tga pixel size");
}
break;
case 11: // black&white, rle
switch (bytesPerPixel) {
case 1: readColor = &readColorBM8!true; break;
case 2: readColor = &readColorBM16!true; break;
default: throw new Exception("invalid tga pixel size");
}
break;
case 1: // colormap, no rle
if (bytesPerPixel != 1) throw new Exception("invalid tga pixel size");
loadCM = true;
readColor = &readColorCM8!false;
break;
case 9: // colormap, rle
if (bytesPerPixel != 1) throw new Exception("invalid tga pixel size");
loadCM = true;
readColor = &readColorCM8!true;
break;
default: throw new Exception("invalid tga format");
}
// check for valid colormap
switch (hdr.cmapType) {
case 0:
if (hdr.cmapFirstIdx != 0 || hdr.cmapSize != 0) throw new Exception("invalid tga colormap type");
break;
case 1:
if (hdr.cmapElementSize != 15 && hdr.cmapElementSize != 16 && hdr.cmapElementSize != 24 && hdr.cmapElementSize != 32) throw new Exception("invalid tga colormap type");
if (hdr.cmapSize == 0) throw new Exception("invalid tga colormap type");
break;
default: throw new Exception("invalid tga colormap type");
}
if (!hdr.zeroBits) throw new Exception("invalid tga header");
void loadColormap () {
if (hdr.cmapType != 1) throw new Exception("invalid tga colormap type");
// calculate color map size
uint colorEntryBytes = 0;
switch (hdr.cmapElementSize) {
case 15:
case 16: colorEntryBytes = 2; break;
case 24: colorEntryBytes = 3; break;
case 32: colorEntryBytes = 4; break;
default: throw new Exception("invalid tga colormap type");
}
uint colorMapBytes = colorEntryBytes*hdr.cmapSize;
if (colorMapBytes == 0) throw new Exception("invalid tga colormap type");
// if we're going to use the color map, read it in.
if (loadCM) {
if (hdr.cmapFirstIdx+hdr.cmapSize > 256) throw new Exception("invalid tga colormap type");
ubyte readCMB () {
if (colorMapBytes == 0) return 0;
--colorMapBytes;
return readByte;
}
cmap[] = Color.black;
auto cmp = cmap.ptr;
switch (colorEntryBytes) {
case 2:
foreach (immutable n; 0..hdr.cmapSize) {
uint v = readCMB();
v |= readCMB()<<8;
cmp.b = cmap16.ptr[v&0x1f];
cmp.g = cmap16.ptr[(v>>5)&0x1f];
cmp.r = cmap16.ptr[(v>>10)&0x1f];
++cmp;
}
break;
case 3:
foreach (immutable n; 0..hdr.cmapSize) {
cmp.b = readCMB();
cmp.g = readCMB();
cmp.r = readCMB();
++cmp;
}
break;
case 4:
foreach (immutable n; 0..hdr.cmapSize) {
cmp.b = readCMB();
cmp.g = readCMB();
cmp.r = readCMB();
cmp.a = readCMB();
++cmp;
}
break;
default: throw new Exception("invalid tga colormap type");
}
} else {
// skip colormap
fl.seek(colorMapBytes, Seek.Cur);
}
}
// now load the data
fl.seek(hdr.idsize, Seek.Cur);
if (hdr.cmapType != 0) loadColormap();
// we don't know if alpha is premultiplied yet
bool hasAlpha = (bytesPerPixel == 4);
bool validAlpha = hasAlpha;
bool premult = false;
auto tcimg = new TrueColorImage(hdr.width, hdr.height);
scope(failure) .destroy(tcimg);
{
// read image data
immutable bool xflip = hdr.xflip, yflip = hdr.yflip;
Color* pixdata = tcimg.imageData.colors.ptr;
if (yflip) pixdata += (hdr.height-1)*hdr.width;
foreach (immutable y; 0..hdr.height) {
auto d = pixdata;
if (xflip) d += hdr.width-1;
foreach (immutable x; 0..hdr.width) {
*d = readColor(&readByte);
if (xflip) --d; else ++d;
}
if (yflip) pixdata -= hdr.width; else pixdata += hdr.width;
}
}
if (hasAlpha) {
if (extfooter.extofs != 0) {
Extension ext;
fl.seek(extfooter.extofs);
fl.readStruct(ext);
// some idiotic writers set 494 instead 495, tolerate that
if (ext.size < 494) throw new Exception("invalid tga extension record");
if (ext.attrType == 4) {
// premultiplied alpha
foreach (ref Color clr; tcimg.imageData.colors) {
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);
}
}
} else if (ext.attrType != 3) {
validAlpha = false;
}
} else {
// some writers sets all alphas to zero, check for that
validAlpha = false;
foreach (ref Color clr; tcimg.imageData.colors) if (clr.a != 0) { validAlpha = true; break; }
}
if (!validAlpha) foreach (ref Color clr; tcimg.imageData.colors) clr.a = 255;
}
return tcimg;
}
// ////////////////////////////////////////////////////////////////////////// //
private:
static if (!ArsdTargaHasIVVFS) {
import core.stdc.stdio : SEEK_SET, SEEK_CUR, SEEK_END;
enum Seek : int {
Set = SEEK_SET,
Cur = SEEK_CUR,
End = SEEK_END,
}
// ////////////////////////////////////////////////////////////////////////// //
// augmentation checks
// is this "low-level" stream that can be read?
enum isLowLevelStreamR(T) = is(typeof((inout int=0) {
auto t = T.init;
ubyte[1] b;
ptrdiff_t r = t.read(b.ptr, 1);
}));
// is this "low-level" stream that can be written?
enum isLowLevelStreamW(T) = is(typeof((inout int=0) {
auto t = T.init;
ubyte[1] b;
ptrdiff_t w = t.write(b.ptr, 1);
}));
// is this "low-level" stream that can be seeked?
enum isLowLevelStreamS(T) = is(typeof((inout int=0) {
auto t = T.init;
long p = t.lseek(0, 0);
}));
// ////////////////////////////////////////////////////////////////////////// //
// augment low-level streams with `rawRead`
T[] rawRead(ST, T) (auto ref ST st, T[] buf) if (isLowLevelStreamR!ST && !is(T == const) && !is(T == immutable)) {
if (buf.length > 0) {
auto res = st.read(buf.ptr, buf.length*T.sizeof);
if (res == -1 || res%T.sizeof != 0) throw new Exception("read error");
return buf[0..res/T.sizeof];
} else {
return buf[0..0];
}
}
// augment low-level streams with `rawWrite`
void rawWrite(ST, T) (auto ref ST st, in T[] buf) if (isLowLevelStreamW!ST) {
if (buf.length > 0) {
auto res = st.write(buf.ptr, buf.length*T.sizeof);
if (res == -1 || res%T.sizeof != 0) throw new Exception("write error");
}
}
// read exact size or throw error
package(arsd) T[] rawReadExact(ST, T) (auto ref ST st, T[] buf) if (isReadableStream!ST && !is(T == const) && !is(T == immutable)) {
if (buf.length == 0) return buf;
auto left = buf.length*T.sizeof;
auto dp = cast(ubyte*)buf.ptr;
while (left > 0) {
auto res = st.rawRead(cast(void[])(dp[0..left]));
if (res.length == 0) throw new Exception("read error");
dp += res.length;
left -= res.length;
}
return buf;
}
// write exact size or throw error (just for convenience)
void rawWriteExact(ST, T) (auto ref ST st, in T[] buf) if (isWriteableStream!ST) { st.rawWrite(buf); }
// if stream doesn't have `.size`, but can be seeked, emulate it
long size(ST) (auto ref ST st) if (isSeekableStream!ST && !streamHasSize!ST) {
auto opos = st.tell;
st.seek(0, Seek.End);
auto res = st.tell;
st.seek(opos);
return res;
}
// ////////////////////////////////////////////////////////////////////////// //
// check if a given stream supports `eof`
enum streamHasEof(T) = is(typeof((inout int=0) {
auto t = T.init;
bool n = t.eof;
}));
// check if a given stream supports `seek`
enum streamHasSeek(T) = is(typeof((inout int=0) {
import core.stdc.stdio : SEEK_END;
auto t = T.init;
t.seek(0);
t.seek(0, SEEK_END);
}));
// check if a given stream supports `tell`
enum streamHasTell(T) = is(typeof((inout int=0) {
auto t = T.init;
long pos = t.tell;
}));
// check if a given stream supports `size`
enum streamHasSize(T) = is(typeof((inout int=0) {
auto t = T.init;
long pos = t.size;
}));
// check if a given stream supports `rawRead()`.
// it's enough to support `void[] rawRead (void[] buf)`
enum isReadableStream(T) = is(typeof((inout int=0) {
auto t = T.init;
ubyte[1] b;
auto v = cast(void[])b;
t.rawRead(v);
}));
// check if a given stream supports `rawWrite()`.
// it's enough to support `inout(void)[] rawWrite (inout(void)[] buf)`
enum isWriteableStream(T) = is(typeof((inout int=0) {
auto t = T.init;
ubyte[1] b;
t.rawWrite(cast(void[])b);
}));
// check if a given stream supports `.seek(ofs, [whence])`, and `.tell`
enum isSeekableStream(T) = (streamHasSeek!T && streamHasTell!T);
// check if we can get size of a given stream.
// this can be done either with `.size`, or with `.seek` and `.tell`
enum isSizedStream(T) = (streamHasSize!T || isSeekableStream!T);
// ////////////////////////////////////////////////////////////////////////// //
private enum isGoodEndianness(string s) = (s == "LE" || s == "le" || s == "BE" || s == "be");
private template isLittleEndianness(string s) if (isGoodEndianness!s) {
enum isLittleEndianness = (s == "LE" || s == "le");
}
private template isBigEndianness(string s) if (isGoodEndianness!s) {
enum isLittleEndianness = (s == "BE" || s == "be");
}
private template isSystemEndianness(string s) if (isGoodEndianness!s) {
version(LittleEndian) {
enum isSystemEndianness = isLittleEndianness!s;
} else {
enum isSystemEndianness = isBigEndianness!s;
}
}
// ////////////////////////////////////////////////////////////////////////// //
// write integer value of the given type, with the given endianness (default: little-endian)
// usage: st.writeNum!ubyte(10)
void writeNum(T, string es="LE", ST) (auto ref ST st, T n) if (isGoodEndianness!es && isWriteableStream!ST && __traits(isIntegral, T)) {
static assert(T.sizeof <= 8); // just in case
static if (isSystemEndianness!es) {
st.rawWriteExact((&n)[0..1]);
} else {
ubyte[T.sizeof] b = void;
version(LittleEndian) {
// convert to big-endian
foreach_reverse (ref x; b) { x = n&0xff; n >>= 8; }
} else {
// convert to little-endian
foreach (ref x; b) { x = n&0xff; n >>= 8; }
}
st.rawWriteExact(b[]);
}
}
// read integer value of the given type, with the given endianness (default: little-endian)
// usage: auto v = st.readNum!ubyte
T readNum(T, string es="LE", ST) (auto ref ST st) if (isGoodEndianness!es && isReadableStream!ST && __traits(isIntegral, T)) {
static assert(T.sizeof <= 8); // just in case
static if (isSystemEndianness!es) {
T v = void;
st.rawReadExact((&v)[0..1]);
return v;
} else {
ubyte[T.sizeof] b = void;
st.rawReadExact(b[]);
T v = 0;
version(LittleEndian) {
// convert from big-endian
foreach (ubyte x; b) { v <<= 8; v |= x; }
} else {
// conver from little-endian
foreach_reverse (ubyte x; b) { v <<= 8; v |= x; }
}
return v;
}
}
private enum reverseBytesMixin = "
foreach (idx; 0..b.length/2) {
ubyte t = b[idx];
b[idx] = b[$-idx-1];
b[$-idx-1] = t;
}
";
// write floating value of the given type, with the given endianness (default: little-endian)
// usage: st.writeNum!float(10)
void writeNum(T, string es="LE", ST) (auto ref ST st, T n) if (isGoodEndianness!es && isWriteableStream!ST && __traits(isFloating, T)) {
static assert(T.sizeof <= 8);
static if (isSystemEndianness!es) {
st.rawWriteExact((&n)[0..1]);
} else {
import core.stdc.string : memcpy;
ubyte[T.sizeof] b = void;
memcpy(b.ptr, &v, T.sizeof);
mixin(reverseBytesMixin);
st.rawWriteExact(b[]);
}
}
// read floating value of the given type, with the given endianness (default: little-endian)
// usage: auto v = st.readNum!float
T readNum(T, string es="LE", ST) (auto ref ST st) if (isGoodEndianness!es && isReadableStream!ST && __traits(isFloating, T)) {
static assert(T.sizeof <= 8);
T v = void;
static if (isSystemEndianness!es) {
st.rawReadExact((&v)[0..1]);
} else {
import core.stdc.string : memcpy;
ubyte[T.sizeof] b = void;
st.rawReadExact(b[]);
mixin(reverseBytesMixin);
memcpy(&v, b.ptr, T.sizeof);
}
return v;
}
// ////////////////////////////////////////////////////////////////////////// //
void readStruct(string es="LE", SS, ST) (auto ref ST fl, ref SS st)
if (is(SS == struct) && isGoodEndianness!es && isReadableStream!ST)
{
void unserData(T) (ref T v) {
import std.traits : Unqual;
alias UT = Unqual!T;
static if (is(T : V[], V)) {
// array
static if (__traits(isStaticArray, T)) {
foreach (ref it; v) unserData(it);
} else static if (is(UT == char)) {
// special case: dynamic `char[]` array will be loaded as asciiz string
char c;
for (;;) {
if (fl.rawRead((&c)[0..1]).length == 0) break; // don't require trailing zero on eof
if (c == 0) break;
v ~= c;
}
} else {
assert(0, "cannot load dynamic arrays yet");
}
} else static if (is(T : V[K], K, V)) {
assert(0, "cannot load associative arrays yet");
} else static if (__traits(isIntegral, UT) || __traits(isFloating, UT)) {
// this takes care of `*char` and `bool` too
v = cast(UT)fl.readNum!(UT, es);
} else static if (is(T == struct)) {
// struct
import std.traits : FieldNameTuple, hasUDA;
foreach (string fldname; FieldNameTuple!T) {
unserData(__traits(getMember, v, fldname));
}
}
}
unserData(st);
}
}
Reference in New Issue View Git Blame Copy Permalink