From e0a3f3a39da4ef782b13882b20ba5171aa6596ce Mon Sep 17 00:00:00 2001
From: "Adam D. Ruppe" <destructionator@gmail.com>
Date: Fri, 28 Jul 2017 23:23:39 -0400
Subject: [PATCH] ketmar pcx loader

---
 color.d |  40 +----
 image.d |  57 ++++++
 pcx.d   | 544 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 targa.d |   2 +-
 4 files changed, 611 insertions(+), 32 deletions(-)
 create mode 100644 pcx.d

diff --git a/color.d b/color.d
index 0a86795..6695802 100644
--- a/color.d
+++ b/color.d
@@ -823,41 +823,19 @@ interface MemoryImage {
   /// Set image pixel.
 	void setPixel(int x, int y, in Color clr);
 
-	/// Load image from file. This will import arsd.png and arsd.jpeg to do the actual work, and cost nothing if you don't use it.
+	/// Load image from file. This will import arsd.image to do the actual work, and cost nothing if you don't use it.
 	static MemoryImage fromImage(T : const(char)[]) (T filename) @trusted {
-		static if (__traits(compiles, {import arsd.jpeg;})) {
-			// yay, we have jpeg loader here, try it!
-			import arsd.jpeg;
-			bool goodJpeg = false;
-			try {
-				int w, h, c;
-				goodJpeg = detect_jpeg_image_from_file(filename, w, h, c);
-				if (goodJpeg && (w < 1 || h < 1)) goodJpeg = false;
-			} catch (Exception) {} // sorry
-			if (goodJpeg) return readJpeg(filename);
-			enum HasJpeg = true;
+		static if (__traits(compiles, (){import arsd.image;})) {
+			// yay, we have image loader here, try it!
+			import arsd.image;
+			return loadImageFromFile(filename);
 		} else {
-			enum HasJpeg = false;
-		}
-		static if (__traits(compiles, {import arsd.png;})) {
-			// yay, we have png loader here, try it!
-			import arsd.png;
-			static if (is(T == string)) {
-				return readPng(filename);
-			} else {
-				// std.stdio sux!
-				return readPng(filename.idup);
-			}
-			enum HasPng = true;
-		} else {
-			enum HasPng = false;
-		}
-		static if (HasJpeg || HasPng) {
-			throw new Exception("cannot load image '"~filename.idup~"' in unknown format");
-		} else {
-			static assert(0, "please provide 'arsd.png', 'arsd.jpeg' or both to load images!");
+			static assert(0, "please provide 'arsd.image' to load images!");
 		}
 	}
+
+	/// Convenient alias for `fromImage`
+	alias fromImageFile = fromImage;
 }
 
 /// An image that consists of indexes into a color palette. Use [getAsTrueColorImage]() if you don't care about palettes
diff --git a/image.d b/image.d
index 5b99b3d..bd5569f 100644
--- a/image.d
+++ b/image.d
@@ -6,6 +6,7 @@ public import arsd.png;
 public import arsd.jpeg;
 public import arsd.bmp;
 public import arsd.targa;
+public import arsd.pcx;
 
 static if (__traits(compiles, { import iv.vfs; })) enum ArsdImageHasIVVFS = true; else enum ArsdImageHasIVVFS = false;
 
@@ -30,6 +31,7 @@ enum ImageFileFormat {
   Jpeg, ///
   Tga, ///
   Gif, /// we can't load it yet, but we can at least detect it
+  Pcx, /// can load 8BPP and 24BPP pcx images
 }
 
 
@@ -49,6 +51,7 @@ public ImageFileFormat guessImageFormatFromExtension (const(char)[] filename) {
   if (strEquCI(ext, "jpg") || strEquCI(ext, "jpeg")) return ImageFileFormat.Jpeg;
   if (strEquCI(ext, "gif")) return ImageFileFormat.Gif;
   if (strEquCI(ext, "tga")) return ImageFileFormat.Tga;
+  if (strEquCI(ext, "pcx")) return ImageFileFormat.Pcx;
   return ImageFileFormat.Unknown;
 }
 
@@ -142,6 +145,58 @@ public ImageFileFormat guessImageFormatFromMemory (const(void)[] membuf) {
     return true;
   }
   if (guessTarga()) return ImageFileFormat.Tga;
+
+  bool guessPcx() nothrow @trusted @nogc {
+    if (buf.length < 129) return false; // we should have at least header
+
+    ubyte manufacturer = buf.ptr[0];
+    ubyte ver = buf.ptr[1];
+    ubyte encoding = buf.ptr[2];
+    ubyte bitsperpixel = buf.ptr[3];
+    ushort xmin = cast(ushort)(buf.ptr[4]+256*buf.ptr[5]);
+    ushort ymin = cast(ushort)(buf.ptr[6]+256*buf.ptr[7]);
+    ushort xmax = cast(ushort)(buf.ptr[8]+256*buf.ptr[9]);
+    ushort ymax = cast(ushort)(buf.ptr[10]+256*buf.ptr[11]);
+    ubyte reserved = buf.ptr[64];
+    ubyte colorplanes = buf.ptr[65];
+    ushort bytesperline = cast(ushort)(buf.ptr[66]+256*buf.ptr[67]);
+    //ushort palettetype = cast(ushort)(buf.ptr[68]+256*buf.ptr[69]);
+
+    // check some header fields
+    if (manufacturer != 0x0a) return false;
+    if (/*ver != 0 && ver != 2 && ver != 3 &&*/ ver != 5) return false;
+    if (encoding != 0 && encoding != 1) return false;
+
+    int wdt = xmax-xmin+1;
+    int hgt = ymax-ymin+1;
+
+    // arbitrary size limits
+    if (wdt < 1 || wdt > 32000) return false;
+    if (hgt < 1 || hgt > 32000) return false;
+
+    if (bytesperline < wdt) return false;
+
+    // if it's not a 256-color PCX file, and not 24-bit PCX file, gtfo
+    bool bpp24 = false;
+    if (colorplanes == 1) {
+      if (bitsperpixel != 8 && bitsperpixel != 24 && bitsperpixel != 32) return false;
+      bpp24 = (bitsperpixel == 24);
+    } else if (colorplanes == 3 || colorplanes == 4) {
+      if (bitsperpixel != 8) return false;
+      bpp24 = true;
+    }
+
+    // additional checks
+    if (reserved != 0) return false;
+
+    // 8bpp files MUST have palette
+    if (!bpp24 && buf.length < 129+769) return false;
+
+    // it can be pcx
+    return true;
+  }
+  if (guessPcx()) return ImageFileFormat.Pcx;
+
   // dunno
   return ImageFileFormat.Unknown;
 }
@@ -168,6 +223,7 @@ public MemoryImage loadImageFromFile(T:const(char)[]) (T filename) {
       case ImageFileFormat.Jpeg: return readJpeg(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);
     }
   }
 }
@@ -182,6 +238,7 @@ public MemoryImage loadImageFromMemory (const(void)[] membuf) {
     case ImageFileFormat.Jpeg: return readJpegFromMemory(cast(const(ubyte)[])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);
   }
 }
 
diff --git a/pcx.d b/pcx.d
new file mode 100644
index 0000000..b7e30b5
--- /dev/null
+++ b/pcx.d
@@ -0,0 +1,544 @@
+//ketmar: Adam didn't wrote this, don't blame him!
+//TODO: other bpp formats besides 8 and 24
+module arsd.pcx;
+
+import arsd.color;
+import std.stdio : File; // sorry
+
+static if (__traits(compiles, { import iv.vfs; })) enum ArsdPcxHasIVVFS = true; else enum ArsdPcxHasIVVFS = false;
+static if (ArsdPcxHasIVVFS) import iv.vfs;
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+public MemoryImage loadPcxMem (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) {
+      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 loadPcx(rd, filename);
+}
+
+static if (ArsdPcxHasIVVFS) public MemoryImage loadPcx (VFile fl) { return loadPcxImpl(fl, fl.name); }
+public MemoryImage loadPcx (File fl) { return loadPcxImpl(fl, fl.name); }
+public MemoryImage loadPcx(T:const(char)[]) (T fname) {
+  static if (is(T == typeof(null))) {
+    throw new Exception("cannot load nameless tga");
+  } else {
+    static if (ArsdPcxHasIVVFS) {
+      return loadPcx(VFile(fname));
+    } else static if (is(T == string)) {
+      return loadPcx(File(fname), fname);
+    } else {
+      return loadPcx(File(fname.idup), fname);
+    }
+  }
+}
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+// pass filename to ease detection
+// hack around "has scoped destruction, cannot build closure"
+public MemoryImage loadPcx(ST) (auto ref ST fl, const(char)[] filename=null) if (isReadableStream!ST && isSeekableStream!ST) { return loadPcxImpl(fl, filename); }
+
+private MemoryImage loadPcxImpl(ST) (auto ref ST fl, const(char)[] filename) {
+  import core.stdc.stdlib : malloc, free;
+
+  // PCX file header
+  static struct PCXHeader {
+    ubyte manufacturer; // 0x0a --signifies a PCX file
+    ubyte ver; // version 5 is what we look for
+    ubyte encoding; // when 1, it's RLE encoding (only type as of yet)
+    ubyte bitsperpixel; // how many bits to represent 1 pixel
+    ushort xmin, ymin, xmax, ymax; // dimensions of window (really insigned?)
+    ushort hdpi, vdpi; // device resolution (horizontal, vertical)
+    ubyte[16*3] colormap; // 16-color palette
+    ubyte reserved;
+    ubyte colorplanes; // number of color planes
+    ushort bytesperline; // number of bytes per line (per color plane)
+    ushort palettetype; // 1 = color,2 = grayscale (unused in v.5+)
+    ubyte[58] filler; // used to fill-out 128 byte header (useless)
+  }
+
+  bool isGoodExtension (const(char)[] filename) {
+    if (filename.length >= 4) {
+      auto ext = filename[$-4..$];
+      if (ext[0] == '.' && (ext[1] == 'P' || ext[1] == 'p') && (ext[2] == 'C' || ext[2] == 'c') && (ext[3] == 'X' || ext[3] == 'x')) return true;
+    }
+    return false;
+  }
+
+  // check file extension, if any
+  if (filename.length && !isGoodExtension(filename)) return null;
+
+  // we should have at least header
+  if (fl.size < 129) throw new Exception("invalid pcx file size");
+
+  fl.seek(0);
+  PCXHeader hdr;
+  fl.readStruct(hdr);
+
+  // check some header fields
+  if (hdr.manufacturer != 0x0a) throw new Exception("invalid pcx manufacturer");
+  if (/*header.ver != 0 && header.ver != 2 && header.ver != 3 &&*/ hdr.ver != 5) throw new Exception("invalid pcx version");
+  if (hdr.encoding != 0 && hdr.encoding != 1) throw new Exception("invalid pcx compresstion");
+
+  int wdt = hdr.xmax-hdr.xmin+1;
+  int hgt = hdr.ymax-hdr.ymin+1;
+
+  // arbitrary size limits
+  if (wdt < 1 || wdt > 32000) throw new Exception("invalid pcx width");
+  if (hgt < 1 || hgt > 32000) throw new Exception("invalid pcx height");
+
+  if (hdr.bytesperline < wdt) throw new Exception("invalid pcx hdr");
+
+  // if it's not a 256-color PCX file, and not 24-bit PCX file, gtfo
+  bool bpp24 = false;
+  bool hasAlpha = false;
+  if (hdr.colorplanes == 1) {
+    if (hdr.bitsperpixel != 8 && hdr.bitsperpixel != 24 && hdr.bitsperpixel != 32) throw new Exception("invalid pcx bpp");
+    bpp24 = (hdr.bitsperpixel == 24);
+    hasAlpha = (hdr.bitsperpixel == 32);
+  } else if (hdr.colorplanes == 3 || hdr.colorplanes == 4) {
+    if (hdr.bitsperpixel != 8) throw new Exception("invalid pcx bpp");
+    bpp24 = true;
+    hasAlpha = (hdr.colorplanes == 4);
+  }
+
+  { import core.stdc.stdio; printf("colorplanes=%u; bitsperpixel=%u; bytesperline=%u\n", cast(uint)hdr.colorplanes, cast(uint)hdr.bitsperpixel, cast(uint)hdr.bytesperline); }
+
+  // additional checks
+  if (hdr.reserved != 0) throw new Exception("invalid pcx hdr");
+
+  // 8bpp files MUST have palette
+  if (!bpp24 && fl.size < 129+769) throw new Exception("invalid pcx file size");
+
+  void readLine (ubyte* line) {
+    foreach (immutable p; 0..hdr.colorplanes) {
+      int count = 0;
+      ubyte b;
+      foreach (immutable n; 0..hdr.bytesperline) {
+        if (count == 0) {
+          // read next byte, do RLE decompression by the way
+          fl.rawReadExact((&b)[0..1]);
+          if (hdr.encoding) {
+            if ((b&0xc0) == 0xc0) {
+              count = b&0x3f;
+              if (count == 0) throw new Exception("invalid pcx RLE data");
+              fl.rawReadExact((&b)[0..1]);
+            } else {
+              count = 1;
+            }
+          } else {
+            count = 1;
+          }
+        }
+        assert(count > 0);
+        line[n] = b;
+        --count;
+      }
+      // allow excessive counts, why not?
+      line += hdr.bytesperline;
+    }
+  }
+
+  int lsize = hdr.bytesperline*hdr.colorplanes;
+  if (!bpp24 && lsize < 768) lsize = 768; // so we can use it as palette buffer
+  auto line = cast(ubyte*)malloc(lsize);
+  if (line is null) throw new Exception("out of memory");
+  scope(exit) free(line);
+
+  IndexedImage iimg;
+  TrueColorImage timg;
+  scope(failure) { delete timg; delete iimg; }
+
+  if (!bpp24) {
+    iimg = new IndexedImage(wdt, hgt);
+  } else {
+    timg = new TrueColorImage(wdt, hgt);
+  }
+
+  foreach (immutable y; 0..hgt) {
+    readLine(line);
+    if (!bpp24) {
+      import core.stdc.string : memcpy;
+      // 8bpp, with palette
+      memcpy(iimg.data.ptr+wdt*y, line, wdt);
+    } else {
+      // 24bpp
+      auto src = line;
+      auto dest = timg.imageData.bytes.ptr+(wdt*4)*y; //RGBA
+      if (hdr.colorplanes != 1) {
+        // planar
+        foreach (immutable x; 0..wdt) {
+          *dest++ = src[0]; // red
+          *dest++ = src[hdr.bytesperline]; // green
+          *dest++ = src[hdr.bytesperline*2]; // blue
+          if (hasAlpha) {
+            *dest++ = src[hdr.bytesperline*3]; // blue
+          } else {
+            *dest++ = 255; // alpha (opaque)
+          }
+          ++src;
+        }
+      } else {
+        // flat
+        foreach (immutable x; 0..wdt) {
+          *dest++ = *src++; // red
+          *dest++ = *src++; // green
+          *dest++ = *src++; // blue
+          if (hasAlpha) {
+            *dest++ = *src++; // alpha
+          } else {
+            *dest++ = 255; // alpha (opaque)
+          }
+        }
+      }
+    }
+  }
+
+  // read palette
+  if (!bpp24) {
+    fl.seek(-769, Seek.End);
+    if (fl.readNum!ubyte != 12) throw new Exception("invalid pcx palette");
+    // it is guaranteed to have at least 768 bytes in `line`
+    fl.rawReadExact(line[0..768]);
+    if (iimg.palette.length < 256) iimg.palette.length = 256;
+    foreach (immutable cidx; 0..256) {
+      /* nope, it is not in VGA format
+      // transform [0..63] palette to [0..255]
+      int r = line[cidx*3+0]*255/63;
+      int g = line[cidx*3+1]*255/63;
+      int b = line[cidx*3+2]*255/63;
+      iimg.palette[cidx] = Color(r, g, b, 255);
+      */
+      iimg.palette[cidx] = Color(line[cidx*3+0], line[cidx*3+1], line[cidx*3+2], 255);
+    }
+    return iimg;
+  } else {
+    return timg;
+  }
+}
+
+
+// ////////////////////////////////////////////////////////////////////////// //
+private:
+static if (!ArsdPcxHasIVVFS) {
+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
+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);
+}
+}
diff --git a/targa.d b/targa.d
index 07cadb8..895814e 100644
--- a/targa.d
+++ b/targa.d
@@ -487,7 +487,7 @@ T[] rawReadExact(ST, T) (auto ref ST st, T[] buf) if (isReadableStream!ST && !is
 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) {
+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;