Update to bsnes v067 release.

I apologize, bsnes v066 had a small error in the source that resulted in the PPU not synchronizing properly to the CPU. This bug was not exposed in the images I use to test releases. I have also updated the cheat code database, which is maintained by mightymo.

snesfilter/2xsai/2xsai.cpp

@@ -0,0 +1,132 @@
+//2xSaI / Super 2xSaI / Super Eagle filter
+//authors: kode54 and Kreed
+//license: GPL
+
+#include "2xsai.hpp"
+#include "implementation.cpp"
+
+//=====
+//2xSaI
+//=====
+
+void _2xSaIFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  outwidth  = width;
+  outheight = height;
+
+  if(width <= 256 && height <= 240) {
+    outwidth  *= 2;
+    outheight *= 2;
+  }
+}
+
+void _2xSaIFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  if(width > 256 || height > 240) {
+    filter_direct.render(output, outpitch, input, pitch, width, height);
+    return;
+  }
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t *) (((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * 256;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  _2xSaI32( (unsigned char *) temp, 1024, 0, (unsigned char *) output, outpitch, width, height );
+}
+
+_2xSaIFilter::_2xSaIFilter() {
+  temp = new uint32_t[256*240];
+}
+
+_2xSaIFilter::~_2xSaIFilter() {
+  delete[] temp;
+}
+
+//===========
+//Super 2xSaI
+//===========
+
+void Super2xSaIFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  outwidth  = width;
+  outheight = height;
+
+  if(width <= 256 && height <= 240) {
+    outwidth  *= 2;
+    outheight *= 2;
+  }
+}
+
+void Super2xSaIFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  if(width > 256 || height > 240) {
+    filter_direct.render(output, outpitch, input, pitch, width, height);
+    return;
+  }
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t *) (((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * 256;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  Super2xSaI32( (unsigned char *) temp, 1024, 0, (unsigned char *) output, outpitch, width, height );
+}
+
+Super2xSaIFilter::Super2xSaIFilter() {
+  temp = new uint32_t[256*240];
+}
+
+Super2xSaIFilter::~Super2xSaIFilter() {
+  delete[] temp;
+}
+
+//===========
+//Super Eagle
+//===========
+
+void SuperEagleFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  outwidth  = width;
+  outheight = height;
+
+  if(width <= 256 && height <= 240) {
+    outwidth  *= 2;
+    outheight *= 2;
+  }
+}
+
+void SuperEagleFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  if(width > 256 || height > 240) {
+    filter_direct.render(output, outpitch, input, pitch, width, height);
+    return;
+  }
+
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *line_in = (const uint16_t *) (((const uint8_t*)input) + pitch * y);
+    uint32_t *line_out = temp + y * 256;
+    for(unsigned x = 0; x < width; x++) {
+      line_out[x] = colortable[line_in[x]];
+    }
+  }
+
+  SuperEagle32( (unsigned char *) temp, 1024, 0, (unsigned char *) output, outpitch, width, height );
+}
+
+SuperEagleFilter::SuperEagleFilter() {
+  temp = new uint32_t[256*240];
+}
+
+SuperEagleFilter::~SuperEagleFilter() {
+  delete[] temp;
+}

snesfilter/2xsai/2xsai.hpp

@@ -0,0 +1,35 @@
+class _2xSaIFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+
+  _2xSaIFilter();
+  ~_2xSaIFilter();
+
+private:
+  uint32_t *temp;
+} filter_2xsai;
+
+class Super2xSaIFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+
+  Super2xSaIFilter();
+  ~Super2xSaIFilter();
+
+private:
+  uint32_t *temp;
+} filter_super2xsai;
+
+class SuperEagleFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+
+  SuperEagleFilter();
+  ~SuperEagleFilter();
+
+private:
+  uint32_t *temp;
+} filter_supereagle;

snesfilter/Makefile

@@ -0,0 +1,89 @@
+include nall/Makefile
+
+qtlibs := QtCore QtGui
+include nall/qt/Makefile
+
+c     := $(compiler) -std=gnu99
+cpp   := $(subst cc,++,$(compiler)) -std=gnu++0x
+flags := -O3 -I. -Iobj -fomit-frame-pointer $(qtinc)
+link  :=
+
+ifeq ($(platform),x)
+  flags := -fPIC -fopenmp $(flags)
+  link += -s -fopenmp -lpthread -lgomp
+else ifeq ($(platform),osx)
+  flags := -fPIC -fopenmp $(flags)
+  link += -fopenmp -lpthread -lgomp
+else ifeq ($(platform),win)
+  flags := -fopenmp $(flags)
+  link += -fopenmp -lpthread
+endif
+
+objects := snesfilter
+
+compile = \
+  $(strip \
+    $(if $(filter %.c,$<), \
+      $(c) $(flags) $1 -c $< -o $@, \
+      $(if $(filter %.cpp,$<), \
+        $(cpp) $(flags) $1 -c $< -o $@ \
+      ) \
+    ) \
+  )
+
+%.o: $<; $(call compile)
+
+all: build;
+
+objects := $(patsubst %,obj/%.o,$(objects))
+moc_headers := $(call rwildcard,./,%.moc.hpp)
+moc_objects := $(foreach f,$(moc_headers),obj/$(notdir $(patsubst %.moc.hpp,%.moc,$f)))
+
+# automatically run moc on all .moc.hpp (MOC header) files
+%.moc: $<; $(moc) -i $< -o $@
+
+# automatically generate %.moc build rules
+__list = $(moc_headers)
+$(foreach f,$(moc_objects), \
+  $(eval __file = $(word 1,$(__list))) \
+  $(eval __list = $(wordlist 2,$(words $(__list)),$(__list))) \
+  $(eval $f: $(__file)) \
+)
+
+##################
+### snesfilter ###
+##################
+
+obj/snesfilter.o: snesfilter.cpp *
+
+###############
+### targets ###
+###############
+
+build: $(moc_objects) $(objects)
+ifeq ($(platform),x)
+	ar rcs libsnesfilter.a $(objects)
+	$(cpp) $(link) -o libsnesfilter.so -shared -Wl,-soname,libsnesfilter.so.1 $(objects) $(qtlib)
+else ifeq ($(platform),osx)
+	ar rcs libsnesfilter.a $(objects)
+	$(cpp) $(link) -o libsnesfilter.dylib -shared -dynamiclib $(objects) $(qtlib)
+else ifeq ($(platform),win)
+	$(cpp) $(link) -o snesfilter.dll -shared -Wl,--out-implib,libsnesfilter.a $(objects) $(qtlib)
+endif
+
+install:
+ifeq ($(platform),x)
+	install -D -m 755 libsnesfilter.a $(DESTDIR)$(prefix)/lib
+	install -D -m 755 libsnesfilter.so $(DESTDIR)$(prefix)/lib
+	ldconfig -n $(DESTDIR)$(prefix)/lib
+else ifeq ($(platform),osx)
+	cp libsnesfilter.dylib /usr/local/lib/libsnesfilter.dylib
+endif
+
+clean:
+	-@$(call delete,obj/*.o)
+	-@$(call delete,obj/*.moc)
+	-@$(call delete,libsnesfilter.a)
+	-@$(call delete,libsnesfilter.so)
+	-@$(call delete,libsnesfilter.dylib)
+	-@$(call delete,snesfilter.dll)

snesfilter/cc.bat

@@ -0,0 +1,2 @@
+@mingw32-make
+@pause

snesfilter/clean.bat

@@ -0,0 +1 @@
+@mingw32-make clean

snesfilter/direct/direct.cpp

@@ -0,0 +1,23 @@
+#include "direct.hpp"
+
+void DirectFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  outwidth  = width;
+  outheight = height;
+}
+
+void DirectFilter::render(
+  uint32_t *output, unsigned outpitch, const uint16_t *input, unsigned pitch,
+  unsigned width, unsigned height
+) {
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  for(unsigned y = 0; y < height; y++) {
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t p = *input++;
+      *output++ = colortable[p];
+    }
+    input += pitch - width;
+    output += outpitch - width;
+  }
+}

snesfilter/direct/direct.hpp

@@ -0,0 +1,5 @@
+class DirectFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+} filter_direct;

snesfilter/hq2x/hq2x.cpp

@@ -0,0 +1,195 @@
+//HQ2x filter
+//authors: byuu and blargg
+//license: public domain
+//
+//note: this is a clean reimplementation of the original HQ2x filter, which was
+//written by Maxim Stepin (MaxSt). it is not 100% identical, but very similar.
+
+#include "hq2x.hpp"
+
+void HQ2xFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  if(width > 256 || height > 240) return filter_direct.size(outwidth, outheight, width, height);
+  outwidth  = width  * 2;
+  outheight = height * 2;
+}
+
+void HQ2xFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  if(width > 256 || height > 240) {
+    filter_direct.render(output, outpitch, input, pitch, width, height);
+    return;
+  }
+
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  #pragma omp parallel for
+  for(unsigned y = 0; y < height; y++) {
+    const uint16_t *in = input + y * pitch;
+    uint32_t *out0 = output + y * outpitch * 2;
+    uint32_t *out1 = output + y * outpitch * 2 + outpitch;
+
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    in++;
+    *out0++ = 0; *out0++ = 0;
+    *out1++ = 0; *out1++ = 0;
+
+    for(unsigned x = 1; x < 256 - 1; x++) {
+      uint16_t A = *(in - prevline - 1);
+      uint16_t B = *(in - prevline + 0);
+      uint16_t C = *(in - prevline + 1);
+      uint16_t D = *(in - 1);
+      uint16_t E = *(in + 0);
+      uint16_t F = *(in + 1);
+      uint16_t G = *(in + nextline - 1);
+      uint16_t H = *(in + nextline + 0);
+      uint16_t I = *(in + nextline + 1);
+      uint32_t e = yuvTable[E] + diff_offset;
+
+      uint8_t pattern;
+      pattern  = diff(e, A) << 0;
+      pattern |= diff(e, B) << 1;
+      pattern |= diff(e, C) << 2;
+      pattern |= diff(e, D) << 3;
+      pattern |= diff(e, F) << 4;
+      pattern |= diff(e, G) << 5;
+      pattern |= diff(e, H) << 6;
+      pattern |= diff(e, I) << 7;
+
+      *(out0 + 0) = colortable[blend(hqTable[pattern], E, A, B, D, F, H)]; pattern = rotate[pattern];
+      *(out0 + 1) = colortable[blend(hqTable[pattern], E, C, F, B, H, D)]; pattern = rotate[pattern];
+      *(out1 + 1) = colortable[blend(hqTable[pattern], E, I, H, F, D, B)]; pattern = rotate[pattern];
+      *(out1 + 0) = colortable[blend(hqTable[pattern], E, G, D, H, B, F)];
+
+      in++;
+      out0 += 2;
+      out1 += 2;
+    }
+
+    in++;
+    *out0++ = 0; *out0++ = 0;
+    *out1++ = 0; *out1++ = 0;
+  }
+}
+
+HQ2xFilter::HQ2xFilter() {
+  yuvTable = new uint32_t[32768];
+
+  for(unsigned i = 0; i < 32768; i++) {
+    uint8_t R = (i >>  0) & 31;
+    uint8_t G = (i >>  5) & 31;
+    uint8_t B = (i >> 10) & 31;
+
+    //bgr555->bgr888
+    double r = (R << 3) | (R >> 2);
+    double g = (G << 3) | (G >> 2);
+    double b = (B << 3) | (B >> 2);
+
+    //bgr888->yuv888
+    double y = (r + g + b) * (0.25f * (63.5f / 48.0f));
+    double u = ((r - b) * 0.25f + 128.0f) * (7.5f / 7.0f);
+    double v = ((g * 2.0f - r - b) * 0.125f + 128.0f) * (7.5f / 6.0f);
+
+    yuvTable[i] = ((unsigned)y << 21) + ((unsigned)u << 11) + ((unsigned)v);
+  }
+
+  for(unsigned n = 0; n < 256; n++) {
+    rotate[n] = ((n >> 2) & 0x11) | ((n << 2) & 0x88)
+              | ((n & 0x01) << 5) | ((n & 0x08) << 3)
+              | ((n & 0x10) >> 3) | ((n & 0x80) >> 5);
+  }
+}
+
+HQ2xFilter::~HQ2xFilter() {
+  delete[] yuvTable;
+}
+
+bool HQ2xFilter::same(uint16_t x, uint16_t y) {
+  return !((yuvTable[x] - yuvTable[y] + diff_offset) & diff_mask);
+}
+
+bool HQ2xFilter::diff(uint32_t x, uint16_t y) {
+  return ((x - yuvTable[y]) & diff_mask);
+}
+
+void HQ2xFilter::grow(uint32_t &n) { n |= n << 16; n &= 0x03e07c1f; }
+uint16_t HQ2xFilter::pack(uint32_t n) { n &= 0x03e07c1f; return n | (n >> 16); }
+
+uint16_t HQ2xFilter::blend1(uint32_t A, uint32_t B) {
+  grow(A); grow(B);
+  A = (A * 3 + B) >> 2;
+  return pack(A);
+}
+
+uint16_t HQ2xFilter::blend2(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 2 + B + C) >> 2);
+}
+
+uint16_t HQ2xFilter::blend3(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 5 + B * 2 + C) >> 3);
+}
+
+uint16_t HQ2xFilter::blend4(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 6 + B + C) >> 3);
+}
+
+uint16_t HQ2xFilter::blend5(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 2 + (B + C) * 3) >> 3);
+}
+
+uint16_t HQ2xFilter::blend6(uint32_t A, uint32_t B, uint32_t C) {
+  grow(A); grow(B); grow(C);
+  return pack((A * 14 + B + C) >> 4);
+}
+
+uint16_t HQ2xFilter::blend(unsigned rule, uint16_t E, uint16_t A, uint16_t B, uint16_t D, uint16_t F, uint16_t H) {
+  switch(rule) { default:
+    case  0: return E;
+    case  1: return blend1(E, A);
+    case  2: return blend1(E, D);
+    case  3: return blend1(E, B);
+    case  4: return blend2(E, D, B);
+    case  5: return blend2(E, A, B);
+    case  6: return blend2(E, A, D);
+    case  7: return blend3(E, B, D);
+    case  8: return blend3(E, D, B);
+    case  9: return blend4(E, D, B);
+    case 10: return blend5(E, D, B);
+    case 11: return blend6(E, D, B);
+    case 12: return same(B, D) ? blend2(E, D, B) : E;
+    case 13: return same(B, D) ? blend5(E, D, B) : E;
+    case 14: return same(B, D) ? blend6(E, D, B) : E;
+    case 15: return same(B, D) ? blend2(E, D, B) : blend1(E, A);
+    case 16: return same(B, D) ? blend4(E, D, B) : blend1(E, A);
+    case 17: return same(B, D) ? blend5(E, D, B) : blend1(E, A);
+    case 18: return same(B, F) ? blend3(E, B, D) : blend1(E, D);
+    case 19: return same(D, H) ? blend3(E, D, B) : blend1(E, B);
+  }
+}
+
+const uint8_t HQ2xFilter::hqTable[256] = {
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 15, 12, 5,  3, 17, 13,
+  4, 4, 6, 18, 4, 4, 6, 18, 5,  3, 12, 12, 5,  3,  1, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 17, 13, 5,  3, 16, 14,
+  4, 4, 6, 18, 4, 4, 6, 18, 5,  3, 16, 12, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5, 19, 12, 12, 5, 19, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5, 19,  1, 12, 5, 19,  1, 14,
+  4, 4, 6,  2, 4, 4, 6, 18, 5,  3, 16, 12, 5, 19,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 15, 12, 5,  3, 17, 13,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 17, 13, 5,  3, 16, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 13, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3, 16, 13,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3,  1, 12,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3, 16, 12, 5,  3,  1, 14,
+  4, 4, 6,  2, 4, 4, 6,  2, 5,  3,  1, 12, 5,  3,  1, 14,
+};

snesfilter/hq2x/hq2x.hpp

@@ -0,0 +1,30 @@
+class HQ2xFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+
+  HQ2xFilter();
+  ~HQ2xFilter();
+
+private:
+  enum {
+    diff_offset = (0x440 << 21) + (0x207 << 11) + 0x407,
+    diff_mask   = (0x380 << 21) + (0x1f0 << 11) + 0x3f0,
+  };
+
+  static const uint8_t hqTable[256];
+  uint32_t *yuvTable;
+  uint8_t rotate[256];
+
+  alwaysinline bool same(uint16_t x, uint16_t y);
+  alwaysinline bool diff(uint32_t x, uint16_t y);
+  alwaysinline void grow(uint32_t &n);
+  alwaysinline uint16_t pack(uint32_t n);
+  alwaysinline uint16_t blend1(uint32_t A, uint32_t B);
+  alwaysinline uint16_t blend2(uint32_t A, uint32_t B, uint32_t C);
+  alwaysinline uint16_t blend3(uint32_t A, uint32_t B, uint32_t C);
+  alwaysinline uint16_t blend4(uint32_t A, uint32_t B, uint32_t C);
+  alwaysinline uint16_t blend5(uint32_t A, uint32_t B, uint32_t C);
+  alwaysinline uint16_t blend6(uint32_t A, uint32_t B, uint32_t C);
+  alwaysinline uint16_t blend(unsigned rule, uint16_t E, uint16_t A, uint16_t B, uint16_t D, uint16_t F, uint16_t H);
+} filter_hq2x;

snesfilter/lq2x/lq2x.cpp

@@ -0,0 +1,53 @@
+#include "lq2x.hpp"
+
+void LQ2xFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  if(width > 256 || height > 240) return filter_direct.size(outwidth, outheight, width, height);
+  outwidth  = width  * 2;
+  outheight = height * 2;
+}
+
+void LQ2xFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  if(width > 256 || height > 240) {
+    filter_direct.render(output, outpitch, input, pitch, width, height);
+    return;
+  }
+
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  uint32_t *out0 = output;
+  uint32_t *out1 = output + outpitch;
+
+  for(unsigned y = 0; y < height; y++) {
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t A = *(input - prevline);
+      uint16_t B = (x >   0) ? *(input - 1) : *input;
+      uint16_t C = *input;
+      uint16_t D = (x < 255) ? *(input + 1) : *input;
+      uint16_t E = *(input++ + nextline);
+      uint32_t c = colortable[C];
+
+      if(A != E && B != D) {
+        *out0++ = (A == B ? colortable[C + A - ((C ^ A) & 0x0421) >> 1] : c);
+        *out0++ = (A == D ? colortable[C + A - ((C ^ A) & 0x0421) >> 1] : c);
+        *out1++ = (E == B ? colortable[C + E - ((C ^ E) & 0x0421) >> 1] : c);
+        *out1++ = (E == D ? colortable[C + E - ((C ^ E) & 0x0421) >> 1] : c);
+      } else {
+        *out0++ = c;
+        *out0++ = c;
+        *out1++ = c;
+        *out1++ = c;
+      }
+    }
+
+    input += pitch - width;
+    out0 += outpitch + outpitch - 512;
+    out1 += outpitch + outpitch - 512;
+  }
+}

snesfilter/lq2x/lq2x.hpp

@@ -0,0 +1,5 @@
+class LQ2xFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+} filter_lq2x;

snesfilter/nall/Makefile

@@ -1,4 +1,4 @@
-# Makefile.string
+# Makefile
 # author: byuu
 # license: public domain
 
@@ -10,6 +10,50 @@
 [space] :=
 [space] +=
 
+#####
+# platform detection
+#####
+
+ifeq ($(platform),)
+  uname := $(shell uname -a)
+  ifeq ($(uname),)
+    platform := win
+    delete = del $(subst /,\,$1)
+  else ifneq ($(findstring Darwin,$(uname)),)
+    platform := osx
+    delete = rm -f $1
+  else
+    platform := x
+    delete = rm -f $1
+  endif
+endif
+
+ifeq ($(compiler),)
+  ifeq ($(platform),osx)
+    compiler := gcc-mp-4.4
+  else
+    compiler := gcc
+  endif
+endif
+
+ifeq ($(prefix),)
+  prefix := /usr/local
+endif
+
+#####
+# function rwildcard(directory, pattern)
+#####
+rwildcard = \
+  $(strip \
+    $(filter $(if $2,$2,%), \
+      $(foreach f, \
+        $(wildcard $1*), \
+        $(eval t = $(call rwildcard,$f/)) \
+        $(if $t,$t,$f) \
+      ) \
+    ) \
+  )
+
 #####
 # function strtr(source, from, to)
 #####

snesfilter/nall/algorithm.hpp

@@ -0,0 +1,17 @@
+#ifndef NALL_ALGORITHM_HPP
+#define NALL_ALGORITHM_HPP
+
+#undef min
+#undef max
+
+namespace nall {
+  template<typename T, typename U> T min(const T &t, const U &u) {
+    return t < u ? t : u;
+  }
+
+  template<typename T, typename U> T max(const T &t, const U &u) {
+    return t > u ? t : u;
+  }
+}
+
+#endif

snesfilter/nall/any.hpp

@@ -2,8 +2,8 @@
 #define NALL_ANY_HPP
 
 #include <typeinfo>
+#include <type_traits>
 #include <nall/static.hpp>
-#include <nall/traits.hpp>
 
 namespace nall {
   class any {
@@ -13,8 +13,8 @@ namespace nall {
 
     template<typename T> any& operator=(const T& value_) {
       typedef typename static_if<
-        is_array<T>::value,
-        typename remove_extent<typename add_const<T>::type>::type*,
+        std::is_array<T>::value,
+        typename std::remove_extent<typename std::add_const<T>::type>::type*,
         T
       >::type auto_t;
 
@@ -49,13 +49,13 @@ namespace nall {
   };
 
   template<typename T> T any_cast(any &value) {
-    typedef typename remove_reference<T>::type nonref;
+    typedef typename std::remove_reference<T>::type nonref;
     if(value.type() != typeid(nonref)) throw;
     return static_cast<any::holder<nonref>*>(value.container)->value;
   }
 
   template<typename T> T any_cast(const any &value) {
-    typedef const typename remove_reference<T>::type nonref;
+    typedef const typename std::remove_reference<T>::type nonref;
     if(value.type() != typeid(nonref)) throw;
     return static_cast<any::holder<nonref>*>(value.container)->value;
   }

snesfilter/nall/array.hpp

@@ -2,8 +2,14 @@
 #define NALL_ARRAY_HPP
 
 #include <stdlib.h>
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/concept.hpp>
+#include <nall/foreach.hpp>
+#include <nall/utility.hpp>
 
 namespace nall {
   //dynamic vector array
@@ -44,26 +50,50 @@ namespace nall {
       return pool;
     }
 
-    void add(const T data) {
+    void append(const T data) {
       operator[](buffersize) = data;
     }
 
+    template<typename U> void insert(unsigned index, const U list) {
+      unsigned listsize = container_size(list);
+      resize(buffersize + listsize);
+      memmove(pool + index + listsize, pool + index, (buffersize - index) * sizeof(T));
+      foreach(item, list) pool[index++] = item;
+    }
+
+    void insert(unsigned index, const T item) {
+      insert(index, array<T>{ item });
+    }
+
+    void remove(unsigned index, unsigned count = 1) {
+      for(unsigned i = index; count + i < buffersize; i++) {
+        pool[i] = pool[count + i];
+      }
+      if(count + index >= buffersize) resize(index);  //every element >= index was removed
+      else resize(buffersize - count);
+    }
+
+    optional<unsigned> find(const T data) {
+      for(unsigned i = 0; i < size(); i++) if(pool[i] == data) return { true, i };
+      return { false, 0 };
+    }
+
     void clear() {
       memset(pool, 0, buffersize * sizeof(T));
     }
 
-    array() {
-      pool = 0;
-      poolsize = 0;
-      buffersize = 0;
+    array() : pool(0), poolsize(0), buffersize(0) {
     }
 
-    ~array() { reset(); }
-
-    array(const array &source) : pool(0) {
-      operator=(source);
+    array(std::initializer_list<T> list) : pool(0), poolsize(0), buffersize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
     }
 
+    ~array() {
+      reset();
+    }
+
+    //copy
     array& operator=(const array &source) {
       if(pool) free(pool);
       buffersize = source.buffersize;
@@ -73,6 +103,26 @@ namespace nall {
       return *this;
     }
 
+    array(const array &source) : pool(0), poolsize(0), buffersize(0) {
+      operator=(source);
+    }
+
+    //move
+    array& operator=(array &&source) {
+      if(pool) free(pool);
+      pool = source.pool;
+      poolsize = source.poolsize;
+      buffersize = source.buffersize;
+      source.pool = 0;
+      source.reset();
+      return *this;
+    }
+
+    array(array &&source) : pool(0), poolsize(0), buffersize(0) {
+      operator=(std::move(source));
+    }
+
+    //index
     inline T& operator[](unsigned index) {
       if(index >= buffersize) resize(index + 1);
       if(index >= buffersize) throw "array[] out of bounds";
@@ -84,6 +134,8 @@ namespace nall {
       return pool[index];
     }
   };
+
+  template<typename T> struct has_size<array<T>> { enum { value = true }; };
 }
 
 #endif

snesfilter/nall/base64.hpp

@@ -2,15 +2,13 @@
 #define NALL_BASE64_HPP
 
 #include <string.h>
-
-#include <nall/new.hpp>
 #include <nall/stdint.hpp>
 
 namespace nall {
   class base64 {
   public:
     static bool encode(char *&output, const uint8_t* input, unsigned inlength) {
-      output = new(zeromemory) char[inlength * 8 / 6 + 6];
+      output = new char[inlength * 8 / 6 + 6]();
 
       unsigned i = 0, o = 0;
       while(i < inlength) {
@@ -41,7 +39,7 @@ namespace nall {
 
     static bool decode(uint8_t *&output, unsigned &outlength, const char *input) {
       unsigned inlength = strlen(input), infix = 0;
-      output = new(zeromemory) uint8_t[inlength];
+      output = new uint8_t[inlength]();
 
       unsigned i = 0, o = 0;
       while(i < inlength) {

snesfilter/nall/concept.hpp

@@ -0,0 +1,34 @@
+#ifndef NALL_CONCEPT_HPP
+#define NALL_CONCEPT_HPP
+
+#include <nall/static.hpp>
+#include <nall/utility.hpp>
+
+namespace nall {
+  //unsigned count() const;
+  template<typename T> struct has_count { enum { value = false }; };
+
+  //unsigned length() const;
+  template<typename T> struct has_length { enum { value = false }; };
+
+  //unsigned size() const;
+  template<typename T> struct has_size { enum { value = false }; };
+
+  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_count<T>>::type = 0) {
+    return object.count();
+  }
+
+  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_length<T>>::type = 0) {
+    return object.length();
+  }
+
+  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<has_size<T>>::type = 0) {
+    return object.size();
+  }
+
+  template<typename T> unsigned container_size(const T& object, typename mp_enable_if<std::is_array<T>>::type = 0) {
+    return sizeof(T) / sizeof(typename std::remove_extent<T>::type);
+  }
+}
+
+#endif

snesfilter/nall/config.hpp

@@ -16,24 +16,28 @@ namespace nall {
     template<typename T> struct is_unsigned { enum { value = false }; };
     template<> struct is_unsigned<unsigned> { enum { value = true }; };
 
+    template<typename T> struct is_double { enum { value = false }; };
+    template<> struct is_double<double> { enum { value = true }; };
+
     template<typename T> struct is_string { enum { value = false }; };
     template<> struct is_string<string> { enum { value = true }; };
   }
 
   class configuration {
   public:
-    enum type_t { boolean_t, signed_t, unsigned_t, string_t, unknown_t };
+    enum type_t { boolean_t, signed_t, unsigned_t, double_t, string_t, unknown_t };
     struct item_t {
       uintptr_t data;
       string name;
       string desc;
       type_t type;
 
-      string get() {
+      string get() const {
         switch(type) {
-          case boolean_t:  return (*(bool*)data == false ? "false" : "true");
-          case signed_t:   return string() << (int)*(signed*)data;
-          case unsigned_t: return string() << (int)*(unsigned*)data;
+          case boolean_t:  return string() << *(bool*)data;
+          case signed_t:   return string() << *(signed*)data;
+          case unsigned_t: return string() << *(unsigned*)data;
+          case double_t:   return string() << *(double*)data;
           case string_t:   return string() << "\"" << *(string*)data << "\"";
         }
         return "???";
@@ -42,13 +46,14 @@ namespace nall {
       void set(string s) {
         switch(type) {
           case boolean_t:  *(bool*)data = (s == "true");      break;
-          case signed_t:   *(signed*)data = s;                break;
-          case unsigned_t: *(unsigned*)data = s;              break;
+          case signed_t:   *(signed*)data = strsigned(s);     break;
+          case unsigned_t: *(unsigned*)data = strunsigned(s); break;
+          case double_t:   *(double*)data = strdouble(s);     break;
           case string_t:   trim(s, "\""); *(string*)data = s; break;
         }
       }
     };
-    vector<item_t> list;
+    linear_vector<item_t> list;
 
     template<typename T>
     void attach(T &data, const char *name, const char *desc = "") {
@@ -60,24 +65,24 @@ namespace nall {
       if(configuration_traits::is_boolean<T>::value) list[n].type = boolean_t;
       else if(configuration_traits::is_signed<T>::value) list[n].type = signed_t;
       else if(configuration_traits::is_unsigned<T>::value) list[n].type = unsigned_t;
+      else if(configuration_traits::is_double<T>::value) list[n].type = double_t;
       else if(configuration_traits::is_string<T>::value) list[n].type = string_t;
       else list[n].type = unknown_t;
     }
 
-    bool load(const char *filename) {
+    virtual bool load(const char *filename) {
       string data;
-      if(fread(data, filename) == true) {
-        replace(data, "\r", "");
+      if(data.readfile(filename) == true) {
+        data.replace("\r", "");
         lstring line;
-        split(line, "\n", data);
+        line.split("\n", data);
 
-        for(unsigned i = 0; i < count(line); i++) {
-          int position = qstrpos(line[i], "#");
-          if(position >= 0) line[i][position] = 0;
-          if(qstrpos(line[i], " = ") < 0) continue;
+        for(unsigned i = 0; i < line.size(); i++) {
+          if(auto position = qstrpos(line[i], "#")) line[i][position()] = 0;
+          if(!qstrpos(line[i], " = ")) continue;
 
           lstring part;
-          qsplit(part, " = ", line[i]);
+          part.qsplit(" = ", line[i]);
           trim(part[0]);
           trim(part[1]);
 
@@ -95,11 +100,15 @@ namespace nall {
       }
     }
 
-    bool save(const char *filename) {
+    virtual bool save(const char *filename) const {
       file fp;
       if(fp.open(filename, file::mode_write)) {
         for(unsigned i = 0; i < list.size(); i++) {
-          fp.print(string() << list[i].name << " = " << list[i].get() << " # " << list[i].desc << "\r\n");
+          string output;
+          output << list[i].name << " = " << list[i].get();
+          if(list[i].desc != "") output << " # " << list[i].desc;
+          output << "\r\n";
+          fp.print(output);
         }
 
         fp.close();

snesfilter/nall/detect.hpp

@@ -23,7 +23,7 @@
 
 #if defined(__i386__) || defined(__amd64__) || defined(_M_IX86) || defined(_M_AMD64)
   #define ARCH_LSB
-#elif defined(__powerpc__) || defined(_M_PPC)
+#elif defined(__powerpc__) || defined(_M_PPC) || defined(__BIG_ENDIAN__)
   #define ARCH_MSB
 #endif
 

snesfilter/nall/dictionary.hpp

@@ -6,7 +6,7 @@
 #include <nall/utility.hpp>
 
 namespace nall {
-  class dictionary : noncopyable {
+  class dictionary {
   public:
     string operator[](const char *input) {
       for(unsigned i = 0; i < index_input.size(); i++) {
@@ -15,9 +15,8 @@ namespace nall {
 
       //no match, use input; remove input identifier, if one exists
       if(strbegin(input, "{{")) {
-        int pos = strpos(input, "}}");
-        if(pos >= 0) {
-          string temp = substr(input, pos + 2);
+        if(auto pos = strpos(input, "}}")) {
+          string temp = substr(input, pos() + 2);
           return temp;
         }
       }
@@ -27,17 +26,17 @@ namespace nall {
 
     bool import(const char *filename) {
       string data;
-      if(fread(data, filename) == false) return false;
+      if(data.readfile(filename) == false) return false;
       ltrim_once(data, "\xef\xbb\xbf"); //remove UTF-8 marker, if it exists
-      replace(data, "\r", "");
+      data.replace("\r", "");
 
       lstring line;
-      split(line, "\n", data);
-      for(unsigned i = 0; i < count(line); i++) {
+      line.split("\n", data);
+      for(unsigned i = 0; i < line.size(); i++) {
         lstring part;
         //format: "Input" = "Output"
-        qsplit(part, "=", line[i]);
-        if(count(part) != 2) continue;
+        part.qsplit("=", line[i]);
+        if(part.size() != 2) continue;
 
         //remove whitespace
         trim(part[0]);
@@ -64,6 +63,9 @@ namespace nall {
       reset();
     }
 
+    dictionary& operator=(const dictionary&) = delete;
+    dictionary(const dictionary&) = delete;
+
   protected:
     lstring index_input;
     lstring index_output;

snesfilter/nall/dl.hpp

@@ -0,0 +1,119 @@
+#ifndef NALL_DL_HPP
+#define NALL_DL_HPP
+
+//dynamic linking support
+
+#include <string.h>
+#include <nall/detect.hpp>
+#include <nall/stdint.hpp>
+#include <nall/utility.hpp>
+
+#if defined(PLATFORM_X) || defined(PLATFORM_OSX)
+  #include <dlfcn.h>
+#elif defined(PLATFORM_WIN)
+  #include <windows.h>
+  #include <nall/utf8.hpp>
+#endif
+
+namespace nall {
+  struct library {
+    bool opened() const { return handle; }
+    bool open(const char*);
+    void* sym(const char*);
+    void close();
+
+    library() : handle(0) {}
+    ~library() { close(); }
+
+    library& operator=(const library&) = delete;
+    library(const library&) = delete;
+
+  private:
+    uintptr_t handle;
+  };
+
+  #if defined(PLATFORM_X)
+  inline bool library::open(const char *name) {
+    if(handle) close();
+    char *t = new char[strlen(name) + 256];
+    strcpy(t, "lib");
+    strcat(t, name);
+    strcat(t, ".so");
+    handle = (uintptr_t)dlopen(t, RTLD_LAZY);
+    if(!handle) {
+      strcpy(t, "/usr/local/lib/lib");
+      strcat(t, name);
+      strcat(t, ".so");
+      handle = (uintptr_t)dlopen(t, RTLD_LAZY);
+    }
+    delete[] t;
+    return handle;
+  }
+
+  inline void* library::sym(const char *name) {
+    if(!handle) return 0;
+    return dlsym((void*)handle, name);
+  }
+
+  inline void library::close() {
+    if(!handle) return;
+    dlclose((void*)handle);
+    handle = 0;
+  }
+  #elif defined(PLATFORM_OSX)
+  inline bool library::open(const char *name) {
+    if(handle) close();
+    char *t = new char[strlen(name) + 256];
+    strcpy(t, "lib");
+    strcat(t, name);
+    strcat(t, ".dylib");
+    handle = (uintptr_t)dlopen(t, RTLD_LAZY);
+    if(!handle) {
+      strcpy(t, "/usr/local/lib/lib");
+      strcat(t, name);
+      strcat(t, ".dylib");
+      handle = (uintptr_t)dlopen(t, RTLD_LAZY);
+    }
+    delete[] t;
+    return handle;
+  }
+
+  inline void* library::sym(const char *name) {
+    if(!handle) return 0;
+    return dlsym((void*)handle, name);
+  }
+
+  inline void library::close() {
+    if(!handle) return;
+    dlclose((void*)handle);
+    handle = 0;
+  }
+  #elif defined(PLATFORM_WIN)
+  inline bool library::open(const char *name) {
+    if(handle) close();
+    char *t = new char[strlen(name) + 8];
+    strcpy(t, name);
+    strcat(t, ".dll");
+    handle = (uintptr_t)LoadLibraryW(utf16_t(t));
+    delete[] t;
+    return handle;
+  }
+
+  inline void* library::sym(const char *name) {
+    if(!handle) return 0;
+    return (void*)GetProcAddress((HMODULE)handle, name);
+  }
+
+  inline void library::close() {
+    if(!handle) return;
+    FreeLibrary((HMODULE)handle);
+    handle = 0;
+  }
+  #else
+  inline bool library::open(const char*) { return false; }
+  inline void* library::sym(const char*) { return 0; }
+  inline void library::close() {}
+  #endif
+};
+
+#endif

snesfilter/nall/file.hpp

@@ -4,12 +4,26 @@
 #include <stdio.h>
 #include <string.h>
 
+#if !defined(_WIN32)
+  #include <unistd.h>
+#else
+  #include <io.h>
+#endif
+
 #include <nall/stdint.hpp>
 #include <nall/utf8.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
-  class file : noncopyable {
+  inline FILE* fopen_utf8(const char *utf8_filename, const char *mode) {
+    #if !defined(_WIN32)
+    return fopen(utf8_filename, mode);
+    #else
+    return _wfopen(utf16_t(utf8_filename), utf16_t(mode));
+    #endif
+  }
+
+  class file {
   public:
     enum FileMode { mode_read, mode_write, mode_readwrite, mode_writeread };
     enum SeekMode { seek_absolute, seek_relative };
@@ -112,6 +126,15 @@ namespace nall {
       return file_size;
     }
 
+    bool truncate(unsigned size) {
+      if(!fp) return false;  //file not open
+      #if !defined(_WIN32)
+      return ftruncate(fileno(fp), size) == 0;
+      #else
+      return _chsize(fileno(fp), size) == 0;
+      #endif
+    }
+
     bool end() {
       if(!fp) return true;  //file not open
       return file_offset >= file_size;
@@ -121,7 +144,7 @@ namespace nall {
       #if !defined(_WIN32)
       FILE *fp = fopen(fn, "rb");
       #else
-      FILE *fp = _wfopen(utf16(fn), L"rb");
+      FILE *fp = _wfopen(utf16_t(fn), L"rb");
       #endif
       if(fp) {
         fclose(fp);
@@ -130,6 +153,21 @@ namespace nall {
       return false;
     }
 
+    static unsigned size(const char *fn) {
+      #if !defined(_WIN32)
+      FILE *fp = fopen(fn, "rb");
+      #else
+      FILE *fp = _wfopen(utf16_t(fn), L"rb");
+      #endif
+      unsigned filesize = 0;
+      if(fp) {
+        fseek(fp, 0, SEEK_END);
+        filesize = ftell(fp);
+        fclose(fp);
+      }
+      return filesize;
+    }
+
     bool open() {
       return fp;
     }
@@ -144,10 +182,10 @@ namespace nall {
         case mode_readwrite: fp = fopen(fn, "rb+"); break;
         case mode_writeread: fp = fopen(fn, "wb+"); break;
         #else
-        case mode_read:      fp = _wfopen(utf16(fn), L"rb");  break;
-        case mode_write:     fp = _wfopen(utf16(fn), L"wb+"); break;
-        case mode_readwrite: fp = _wfopen(utf16(fn), L"rb+"); break;
-        case mode_writeread: fp = _wfopen(utf16(fn), L"wb+"); break;
+        case mode_read:      fp = _wfopen(utf16_t(fn), L"rb");  break;
+        case mode_write:     fp = _wfopen(utf16_t(fn), L"wb+"); break;
+        case mode_readwrite: fp = _wfopen(utf16_t(fn), L"rb+"); break;
+        case mode_writeread: fp = _wfopen(utf16_t(fn), L"wb+"); break;
         #endif
       }
       if(!fp) return false;
@@ -180,6 +218,9 @@ namespace nall {
       close();
     }
 
+    file& operator=(const file&) = delete;
+    file(const file&) = delete;
+
   private:
     enum { buffer_size = 1 << 12, buffer_mask = buffer_size - 1 };
     char buffer[buffer_size];

snesfilter/nall/filemap.hpp

@@ -72,7 +72,7 @@ namespace nall {
           break;
       }
 
-      p_filehandle = CreateFileW(utf16(filename), desired_access, FILE_SHARE_READ, NULL,
+      p_filehandle = CreateFileW(utf16_t(filename), desired_access, FILE_SHARE_READ, NULL,
         creation_disposition, FILE_ATTRIBUTE_NORMAL, NULL);
       if(p_filehandle == INVALID_HANDLE_VALUE) return false;
 

snesfilter/nall/foreach.hpp

@@ -0,0 +1,12 @@
+#ifndef NALL_FOREACH_HPP
+#define NALL_FOREACH_HPP
+
+#include <type_traits>
+#include <nall/concept.hpp>
+
+#undef foreach
+#define foreach(iter, object) \
+  for(unsigned foreach_counter = 0, foreach_limit = container_size(object), foreach_once = 0, foreach_broken = 0; foreach_counter < foreach_limit && foreach_broken == 0; foreach_counter++, foreach_once = 0) \
+    for(auto &iter = object[foreach_counter]; foreach_once == 0 && (foreach_broken = 1); foreach_once++, foreach_broken = 0)
+
+#endif

snesfilter/nall/function.hpp

@@ -0,0 +1,90 @@
+#ifndef NALL_FUNCTION_HPP
+#define NALL_FUNCTION_HPP
+
+#include <functional>
+#include <type_traits>
+
+namespace nall {
+  template<typename T> class function;
+
+  template<typename R, typename... P>
+  class function<R (P...)> {
+  private:
+    struct base1 { virtual void func1(P...) {} };
+    struct base2 { virtual void func2(P...) {} };
+    struct derived : base1, virtual base2 {};
+
+    struct data_t {
+      R (*callback)(const data_t&, P...);
+      union {
+        R (*callback_global)(P...);
+        struct {
+          R (derived::*callback_member)(P...);
+          void *object;
+        };
+      };
+    } data;
+
+    static R callback_global(const data_t &data, P... p) {
+      return data.callback_global(p...);
+    }
+
+    template<typename C>
+    static R callback_member(const data_t &data, P... p) {
+      return (((C*)data.object)->*((R (C::*&)(P...))data.callback_member))(p...);
+    }
+
+  public:
+    R operator()(P... p) const { return data.callback(data, p...); }
+    operator bool() const { return data.callback; }
+    void reset() { data.callback = 0; }
+
+    function& operator=(const function &source) { memcpy(&data, &source.data, sizeof(data_t)); return *this; }
+    function(const function &source) { operator=(source); }
+
+    //no pointer
+    function() {
+      data.callback = 0;
+    }
+
+    //symbolic link pointer (nall/dl.hpp::sym, etc)
+    function(void *callback) {
+      data.callback = callback ? &callback_global : 0;
+      data.callback_global = (R (*)(P...))callback;
+    }
+
+    //global function pointer
+    function(R (*callback)(P...)) {
+      data.callback = &callback_global;
+      data.callback_global = callback;
+    }
+
+    //member function pointer
+    template<typename C>
+    function(R (C::*callback)(P...), C *object) {
+      static_assert(sizeof data.callback_member >= sizeof callback, "callback_member is too small");
+      data.callback = &callback_member<C>;
+      (R (C::*&)(P...))data.callback_member = callback;
+      data.object = object;
+    }
+
+    //const member function pointer
+    template<typename C>
+    function(R (C::*callback)(P...) const, C *object) {
+      static_assert(sizeof data.callback_member >= sizeof callback, "callback_member is too small");
+      data.callback = &callback_member<C>;
+      (R (C::*&)(P...))data.callback_member = (R (C::*&)(P...))callback;
+      data.object = object;
+    }
+
+    //lambda function pointer
+    template<typename T>
+    function(T callback) {
+      static_assert(std::is_same<R, typename std::result_of<T(P...)>::type>::value, "lambda mismatch");
+      data.callback = &callback_global;
+      data.callback_global = (R (*)(P...))callback;
+    }
+  };
+}
+
+#endif

snesfilter/nall/input.hpp

@@ -0,0 +1,386 @@
+#ifndef NALL_INPUT_HPP
+#define NALL_INPUT_HPP
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <nall/stdint.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+struct Keyboard;
+Keyboard& keyboard(unsigned = 0);
+
+static const char KeyboardScancodeName[][64] = {
+  "Escape", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12",
+  "PrintScreen", "ScrollLock", "Pause", "Tilde",
+  "Num1", "Num2", "Num3", "Num4", "Num5", "Num6", "Num7", "Num8", "Num9", "Num0",
+  "Dash", "Equal", "Backspace",
+  "Insert", "Delete", "Home", "End", "PageUp", "PageDown",
+  "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
+  "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
+  "LeftBracket", "RightBracket", "Backslash", "Semicolon", "Apostrophe", "Comma", "Period", "Slash",
+  "Keypad1", "Keypad2", "Keypad3", "Keypad4", "Keypad5", "Keypad6", "Keypad7", "Keypad8", "Keypad9", "Keypad0",
+  "Point", "Enter", "Add", "Subtract", "Multiply", "Divide",
+  "NumLock", "CapsLock",
+  "Up", "Down", "Left", "Right",
+  "Tab", "Return", "Spacebar", "Menu",
+  "Shift", "Control", "Alt", "Super",
+};
+
+struct Keyboard {
+  const unsigned ID;
+  enum { Base = 1 };
+  enum { Count = 8, Size = 128 };
+
+  enum Scancode {
+    Escape, F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12,
+    PrintScreen, ScrollLock, Pause, Tilde,
+    Num1, Num2, Num3, Num4, Num5, Num6, Num7, Num8, Num9, Num0,
+    Dash, Equal, Backspace,
+    Insert, Delete, Home, End, PageUp, PageDown,
+    A, B, C, D, E, F, G, H, I, J, K, L, M,
+    N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
+    LeftBracket, RightBracket, Backslash, Semicolon, Apostrophe, Comma, Period, Slash,
+    Keypad1, Keypad2, Keypad3, Keypad4, Keypad5, Keypad6, Keypad7, Keypad8, Keypad9, Keypad0,
+    Point, Enter, Add, Subtract, Multiply, Divide,
+    NumLock, CapsLock,
+    Up, Down, Left, Right,
+    Tab, Return, Spacebar, Menu,
+    Shift, Control, Alt, Super,
+    Limit,
+  };
+
+  static signed numberDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(keyboard(i).belongsTo(scancode)) return i;
+    }
+    return -1;
+  }
+
+  static signed keyDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(keyboard(i).isKey(scancode)) return scancode - keyboard(i).key(Escape);
+    }
+    return -1;
+  }
+
+  static signed modifierDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(keyboard(i).isModifier(scancode)) return scancode - keyboard(i).key(Shift);
+    }
+    return -1;
+  }
+
+  static bool isAnyKey(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(keyboard(i).isKey(scancode)) return true;
+    }
+    return false;
+  }
+
+  static bool isAnyModifier(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(keyboard(i).isModifier(scancode)) return true;
+    }
+    return false;
+  }
+
+  static uint16_t decode(const char *name) {
+    string s(name);
+    if(!strbegin(name, "KB")) return 0;
+    ltrim(s, "KB");
+    unsigned id = strunsigned(s);
+    auto pos = strpos(s, "::");
+    if(!pos) return 0;
+    s = substr(s, pos() + 2);
+    for(unsigned i = 0; i < Limit; i++) {
+      if(s == KeyboardScancodeName[i]) return Base + Size * id + i;
+    }
+    return 0;
+  }
+
+  string encode(uint16_t code) const {
+    unsigned index = 0;
+    for(unsigned i = 0; i < Count; i++) {
+      if(code >= Base + Size * i && code < Base + Size * (i + 1)) {
+        index = code - (Base + Size * i);
+        break;
+      }
+    }
+    return string() << "KB" << ID << "::" << KeyboardScancodeName[index];
+  }
+
+  uint16_t operator[](Scancode code) const { return Base + ID * Size + code; }
+  uint16_t key(unsigned id) const { return Base + Size * ID + id; }
+  bool isKey(unsigned id) const { return id >= key(Escape) && id <= key(Menu); }
+  bool isModifier(unsigned id) const { return id >= key(Shift) && id <= key(Super); }
+  bool belongsTo(uint16_t scancode) const { return isKey(scancode) || isModifier(scancode); }
+
+  Keyboard(unsigned ID_) : ID(ID_) {}
+};
+
+inline Keyboard& keyboard(unsigned id) {
+  static Keyboard kb0(0), kb1(1), kb2(2), kb3(3), kb4(4), kb5(5), kb6(6), kb7(7);
+  switch(id) { default:
+    case 0: return kb0; case 1: return kb1; case 2: return kb2; case 3: return kb3;
+    case 4: return kb4; case 5: return kb5; case 6: return kb6; case 7: return kb7;
+  }
+}
+
+static const char MouseScancodeName[][64] = {
+  "Xaxis", "Yaxis", "Zaxis",
+  "Button0", "Button1", "Button2", "Button3", "Button4", "Button5", "Button6", "Button7",
+};
+
+struct Mouse;
+Mouse& mouse(unsigned = 0);
+
+struct Mouse {
+  const unsigned ID;
+  enum { Base = Keyboard::Base + Keyboard::Size * Keyboard::Count };
+  enum { Count = 8, Size = 16 };
+  enum { Axes = 3, Buttons = 8 };
+
+  enum Scancode {
+    Xaxis, Yaxis, Zaxis,
+    Button0, Button1, Button2, Button3, Button4, Button5, Button6, Button7,
+    Limit,
+  };
+
+  static signed numberDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(mouse(i).belongsTo(scancode)) return i;
+    }
+    return -1;
+  }
+
+  static signed axisDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(mouse(i).isAxis(scancode)) return scancode - mouse(i).axis(0);
+    }
+    return -1;
+  }
+
+  static signed buttonDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(mouse(i).isButton(scancode)) return scancode - mouse(i).button(0);
+    }
+    return -1;
+  }
+
+  static bool isAnyAxis(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(mouse(i).isAxis(scancode)) return true;
+    }
+    return false;
+  }
+
+  static bool isAnyButton(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(mouse(i).isButton(scancode)) return true;
+    }
+    return false;
+  }
+
+  static uint16_t decode(const char *name) {
+    string s(name);
+    if(!strbegin(name, "MS")) return 0;
+    ltrim(s, "MS");
+    unsigned id = strunsigned(s);
+    auto pos = strpos(s, "::");
+    if(!pos) return 0;
+    s = substr(s, pos() + 2);
+    for(unsigned i = 0; i < Limit; i++) {
+      if(s == MouseScancodeName[i]) return Base + Size * id + i;
+    }
+    return 0;
+  }
+
+  string encode(uint16_t code) const {
+    unsigned index = 0;
+    for(unsigned i = 0; i < Count; i++) {
+      if(code >= Base + Size * i && code < Base + Size * (i + 1)) {
+        index = code - (Base + Size * i);
+        break;
+      }
+    }
+    return string() << "MS" << ID << "::" << MouseScancodeName[index];
+  }
+
+  uint16_t operator[](Scancode code) const { return Base + ID * Size + code; }
+  uint16_t axis(unsigned id) const { return Base + Size * ID + Xaxis + id; }
+  uint16_t button(unsigned id) const { return Base + Size * ID + Button0 + id; }
+  bool isAxis(unsigned id) const { return id >= axis(0) && id <= axis(2); }
+  bool isButton(unsigned id) const { return id >= button(0) && id <= button(7); }
+  bool belongsTo(uint16_t scancode) const { return isAxis(scancode) || isButton(scancode); }
+
+  Mouse(unsigned ID_) : ID(ID_) {}
+};
+
+inline Mouse& mouse(unsigned id) {
+  static Mouse ms0(0), ms1(1), ms2(2), ms3(3), ms4(4), ms5(5), ms6(6), ms7(7);
+  switch(id) { default:
+    case 0: return ms0; case 1: return ms1; case 2: return ms2; case 3: return ms3;
+    case 4: return ms4; case 5: return ms5; case 6: return ms6; case 7: return ms7;
+  }
+}
+
+static const char JoypadScancodeName[][64] = {
+  "Hat0", "Hat1", "Hat2", "Hat3", "Hat4", "Hat5", "Hat6", "Hat7",
+  "Axis0", "Axis1", "Axis2", "Axis3", "Axis4", "Axis5", "Axis6", "Axis7",
+  "Axis8", "Axis9", "Axis10", "Axis11", "Axis12", "Axis13", "Axis14", "Axis15",
+  "Button0", "Button1", "Button2", "Button3", "Button4", "Button5", "Button6", "Button7",
+  "Button8", "Button9", "Button10", "Button11", "Button12", "Button13", "Button14", "Button15",
+  "Button16", "Button17", "Button18", "Button19", "Button20", "Button21", "Button22", "Button23",
+  "Button24", "Button25", "Button26", "Button27", "Button28", "Button29", "Button30", "Button31",
+};
+
+struct Joypad;
+Joypad& joypad(unsigned = 0);
+
+struct Joypad {
+  const unsigned ID;
+  enum { Base = Mouse::Base + Mouse::Size * Mouse::Count };
+  enum { Count = 8, Size = 64 };
+  enum { Hats = 8, Axes = 16, Buttons = 32 };
+
+  enum Scancode {
+    Hat0, Hat1, Hat2, Hat3, Hat4, Hat5, Hat6, Hat7,
+    Axis0, Axis1, Axis2, Axis3, Axis4, Axis5, Axis6, Axis7,
+    Axis8, Axis9, Axis10, Axis11, Axis12, Axis13, Axis14, Axis15,
+    Button0, Button1, Button2, Button3, Button4, Button5, Button6, Button7,
+    Button8, Button9, Button10, Button11, Button12, Button13, Button14, Button15,
+    Button16, Button17, Button18, Button19, Button20, Button21, Button22, Button23,
+    Button24, Button25, Button26, Button27, Button28, Button29, Button30, Button31,
+    Limit,
+  };
+
+  enum Hat { HatCenter = 0, HatUp = 1, HatRight = 2, HatDown = 4, HatLeft = 8 };
+
+  static signed numberDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(joypad(i).belongsTo(scancode)) return i;
+    }
+    return -1;
+  }
+
+  static signed hatDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(joypad(i).isHat(scancode)) return scancode - joypad(i).hat(0);
+    }
+    return -1;
+  }
+
+  static signed axisDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(joypad(i).isAxis(scancode)) return scancode - joypad(i).axis(0);
+    }
+    return -1;
+  }
+
+  static signed buttonDecode(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(joypad(i).isButton(scancode)) return scancode - joypad(i).button(0);
+    }
+    return -1;
+  }
+
+  static bool isAnyHat(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(joypad(i).isHat(scancode)) return true;
+    }
+    return false;
+  }
+
+  static bool isAnyAxis(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(joypad(i).isAxis(scancode)) return true;
+    }
+    return false;
+  }
+
+  static bool isAnyButton(uint16_t scancode) {
+    for(unsigned i = 0; i < Count; i++) {
+      if(joypad(i).isButton(scancode)) return true;
+    }
+    return false;
+  }
+
+  static uint16_t decode(const char *name) {
+    string s(name);
+    if(!strbegin(name, "JP")) return 0;
+    ltrim(s, "JP");
+    unsigned id = strunsigned(s);
+    auto pos = strpos(s, "::");
+    if(!pos) return 0;
+    s = substr(s, pos() + 2);
+    for(unsigned i = 0; i < Limit; i++) {
+      if(s == JoypadScancodeName[i]) return Base + Size * id + i;
+    }
+    return 0;
+  }
+
+  string encode(uint16_t code) const {
+    unsigned index = 0;
+    for(unsigned i = 0; i < Count; i++) {
+      if(code >= Base + Size * i && code < Base + Size * (i + 1)) {
+        index = code - (Base + Size * i);
+      }
+    }
+    return string() << "JP" << ID << "::" << JoypadScancodeName[index];
+  }
+
+  uint16_t operator[](Scancode code) const { return Base + ID * Size + code; }
+  uint16_t hat(unsigned id) const { return Base + Size * ID + Hat0 + id; }
+  uint16_t axis(unsigned id) const { return Base + Size * ID + Axis0 + id; }
+  uint16_t button(unsigned id) const { return Base + Size * ID + Button0 + id; }
+  bool isHat(unsigned id) const { return id >= hat(0) && id <= hat(7); }
+  bool isAxis(unsigned id) const { return id >= axis(0) && id <= axis(15); }
+  bool isButton(unsigned id) const { return id >= button(0) && id <= button(31); }
+  bool belongsTo(uint16_t scancode) const { return isHat(scancode) || isAxis(scancode) || isButton(scancode); }
+
+  Joypad(unsigned ID_) : ID(ID_) {}
+};
+
+inline Joypad& joypad(unsigned id) {
+  static Joypad jp0(0), jp1(1), jp2(2), jp3(3), jp4(4), jp5(5), jp6(6), jp7(7);
+  switch(id) { default:
+    case 0: return jp0; case 1: return jp1; case 2: return jp2; case 3: return jp3;
+    case 4: return jp4; case 5: return jp5; case 6: return jp6; case 7: return jp7;
+  }
+}
+
+struct Scancode {
+  enum { None = 0, Limit = Joypad::Base + Joypad::Size * Joypad::Count };
+
+  static uint16_t decode(const char *name) {
+    uint16_t code;
+    code = Keyboard::decode(name);
+    if(code) return code;
+    code = Mouse::decode(name);
+    if(code) return code;
+    code = Joypad::decode(name);
+    if(code) return code;
+    return None;
+  }
+
+  static string encode(uint16_t code) {
+    for(unsigned i = 0; i < Keyboard::Count; i++) {
+      if(keyboard(i).belongsTo(code)) return keyboard(i).encode(code);
+    }
+    for(unsigned i = 0; i < Mouse::Count; i++) {
+      if(mouse(i).belongsTo(code)) return mouse(i).encode(code);
+    }
+    for(unsigned i = 0; i < Joypad::Count; i++) {
+      if(joypad(i).belongsTo(code)) return joypad(i).encode(code);
+    }
+    return "None";
+  }
+};
+
+}
+
+#endif

snesfilter/nall/moduloarray.hpp

@@ -1,7 +1,7 @@
 #ifndef NALL_MODULO_HPP
 #define NALL_MODULO_HPP
 
-#include <nall/new.hpp>
+#include <nall/serializer.hpp>
 
 namespace nall {
   template<typename T, int size> class modulo_array {
@@ -20,8 +20,12 @@ namespace nall {
       buffer[index + size + size] = value;
     }
 
+    void serialize(serializer &s) {
+      s.array(buffer, size * 3);
+    }
+
     modulo_array() {
-      buffer = new(zeromemory) T[size * 3];
+      buffer = new T[size * 3]();
     }
 
     ~modulo_array() {

snesfilter/nall/platform.hpp

@@ -1,6 +1,8 @@
 #ifndef NALL_PLATFORM_HPP
 #define NALL_PLATFORM_HPP
 
+#include <nall/utf8.hpp>
+
 //=========================
 //standard platform headers
 //=========================
@@ -20,6 +22,7 @@
   #include <io.h>
   #include <direct.h>
   #include <shlobj.h>
+  #undef interface
 #else
   #include <unistd.h>
   #include <pwd.h>
@@ -49,6 +52,7 @@
   #define getcwd      _getcwd
   #define ftruncate   _chsize
   #define putenv      _putenv
+  #define mkdir(n, m) _wmkdir(nall::utf16_t(n))
   #define rmdir       _rmdir
   #define vsnprintf   _vsnprintf
   #define usleep(n)   Sleep(n / 1000)
@@ -61,11 +65,11 @@
 #if defined(__GNUC__)
   #define noinline      __attribute__((noinline))
   #define inline        inline
-  #define alwaysinline  __attribute__((always_inline))
+  #define alwaysinline  inline __attribute__((always_inline))
 #elif defined(_MSC_VER)
   #define noinline      __declspec(noinline)
   #define inline        inline
-  #define alwaysinline  __forceinline
+  #define alwaysinline  inline __forceinline
 #else
   #define noinline
   #define inline        inline
@@ -73,3 +77,4 @@
 #endif
 
 #endif
+

snesfilter/nall/priorityqueue.hpp

@@ -3,6 +3,7 @@
 
 #include <limits>
 #include <nall/function.hpp>
+#include <nall/serializer.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -13,7 +14,7 @@ namespace nall {
   //O(1)     find   (tick)
   //O(log n) insert (enqueue)
   //O(log n) remove (dequeue)
-  template<typename type_t> class priority_queue : noncopyable {
+  template<typename type_t> class priority_queue {
   public:
     inline void tick(unsigned ticks) {
       basecounter += ticks;
@@ -65,9 +66,19 @@ namespace nall {
       heapsize = 0;
     }
 
+    void serialize(serializer &s) {
+      s.integer(basecounter);
+      s.integer(heapsize);
+      for(unsigned n = 0; n < heapcapacity; n++) {
+        s.integer(heap[n].counter);
+        s.integer(heap[n].event);
+      }
+    }
+
     priority_queue(unsigned size, function<void (type_t)> callback_ = &priority_queue_nocallback<type_t>)
     : callback(callback_) {
       heap = new heap_t[size];
+      heapcapacity = size;
       reset();
     }
 
@@ -75,10 +86,14 @@ namespace nall {
       delete[] heap;
     }
 
+    priority_queue& operator=(const priority_queue&) = delete;
+    priority_queue(const priority_queue&) = delete;
+
   private:
     function<void (type_t)> callback;
     unsigned basecounter;
     unsigned heapsize;
+    unsigned heapcapacity;
     struct heap_t {
       unsigned counter;
       type_t event;

snesfilter/nall/property.hpp

@@ -0,0 +1,91 @@
+#ifndef NALL_PROPERTY_HPP
+#define NALL_PROPERTY_HPP
+
+//nall::property implements ownership semantics into container classes
+//example: property<owner>::readonly<type> implies that only owner has full
+//access to type; and all other code has readonly access.
+//
+//this code relies on extended friend semantics from C++0x to work, as it
+//declares a friend class via a template paramter. it also exploits a bug in
+//G++ 4.x to work even in C++98 mode.
+//
+//if compiling elsewhere, simply remove the friend class and private semantics
+
+//property can be used either of two ways:
+//struct foo {
+//  property<foo>::readonly<bool> x;
+//  property<foo>::readwrite<int> y;
+//};
+//-or-
+//struct foo : property<foo> {
+//  readonly<bool> x;
+//  readwrite<int> y;
+//};
+
+//return types are const T& (byref) instead fo T (byval) to avoid major speed
+//penalties for objects with expensive copy constructors
+
+//operator-> provides access to underlying object type:
+//readonly<Object> foo;
+//foo->bar();
+//... will call Object::bar();
+
+//operator='s reference is constant so as to avoid leaking a reference handle
+//that could bypass access restrictions
+
+//both constant and non-constant operators are provided, though it may be
+//necessary to cast first, for instance:
+//struct foo : property<foo> { readonly<int> bar; } object;
+//int main() { int value = const_cast<const foo&>(object); }
+
+//writeonly is useful for objects that have non-const reads, but const writes.
+//however, to avoid leaking handles, the interface is very restricted. the only
+//way to write is via operator=, which requires conversion via eg copy
+//constructor. example:
+//struct foo {
+//  foo(bool value) { ... }
+//};
+//writeonly<foo> bar;
+//bar = true;
+
+namespace nall {
+  template<typename C> struct property {
+    template<typename T> struct traits { typedef T type; };
+
+    template<typename T> struct readonly {
+      const T* operator->() const { return &value; }
+      const T& operator()() const { return value; }
+      operator const T&() const { return value; }
+    private:
+      T* operator->() { return &value; }
+      operator T&() { return value; }
+      const T& operator=(const T& value_) { return value = value_; }
+      T value;
+      friend class traits<C>::type;
+    };
+
+    template<typename T> struct writeonly {
+      void operator=(const T& value_) { value = value_; }
+    private:
+      const T* operator->() const { return &value; }
+      const T& operator()() const { return value; }
+      operator const T&() const { return value; }
+      T* operator->() { return &value; }
+      operator T&() { return value; }
+      T value;
+      friend class traits<C>::type;
+    };
+
+    template<typename T> struct readwrite {
+      const T* operator->() const { return &value; }
+      const T& operator()() const { return value; }
+      operator const T&() const { return value; }
+      T* operator->() { return &value; }
+      operator T&() { return value; }
+      const T& operator=(const T& value_) { return value = value_; }
+      T value;
+    };
+  };
+}
+
+#endif

snesfilter/nall/qt/Makefile

@@ -0,0 +1,55 @@
+# requires nall/Makefile
+
+# imports:
+# $(qtlibs) -- list of Qt components to link against
+
+# exports the following symbols:
+# $(moc)   -- meta-object compiler
+# $(rcc)   -- resource compiler
+# $(qtinc) -- includes for compiling
+# $(qtlib) -- libraries for linking
+
+ifeq ($(moc),)
+moc := moc
+endif
+
+ifeq ($(rcc),)
+rcc := rcc
+endif
+
+ifeq ($(platform),x)
+  qtinc := `pkg-config --cflags $(qtlibs)`
+  qtlib := `pkg-config --libs $(qtlibs)`
+else ifeq ($(platform),osx)
+  qtinc := $(foreach lib,$(qtlibs),-I/Library/Frameworks/$(lib).framework/Versions/4/Headers)
+
+  qtlib := -L/Library/Frameworks
+  qtlib += $(foreach lib,$(qtlibs),-framework $(lib))
+  qtlib += -framework Carbon
+  qtlib += -framework Cocoa
+  qtlib += -framework OpenGL
+  qtlib += -framework AppKit
+  qtlib += -framework ApplicationServices
+else ifeq ($(platform),win)
+  ifeq ($(qtpath),)
+    # find Qt install directory from PATH environment variable
+    qtpath := $(foreach path,$(subst ;, ,$(PATH)),$(if $(wildcard $(path)/$(moc).exe),$(path)))
+    qtpath := $(strip $(qtpath))
+    qtpath := $(subst \,/,$(qtpath))
+    qtpath := $(patsubst %/bin,%,$(qtpath))
+  endif
+
+  qtinc := -I$(qtpath)/include
+  qtinc += $(foreach lib,$(qtlibs),-I$(qtpath)/include/$(lib))
+
+  qtlib := -L$(qtpath)/lib
+  qtlib += -L$(qtpath)/plugins/imageformats
+
+  qtlib += $(foreach lib,$(qtlibs),-l$(lib)4)
+  qtlib += -lmingw32 -lqtmain -lcomdlg32 -loleaut32 -limm32 -lwinmm
+  qtlib += -lwinspool -lmsimg32 -lole32 -ladvapi32 -lws2_32 -luuid -lgdi32
+  qtlib += $(foreach lib,$(qtlibs),-l$(lib)4)
+
+  # optional image-file support:
+  # qtlib += -lqjpeg -lqmng
+endif

snesfilter/nall/qt/check-action.moc.hpp

@@ -0,0 +1,41 @@
+#ifndef NALL_QT_CHECKACTION_HPP
+#define NALL_QT_CHECKACTION_HPP
+
+namespace nall {
+
+class CheckAction : public QAction {
+  Q_OBJECT
+
+public:
+  bool isChecked() const;
+  void setChecked(bool);
+  void toggleChecked();
+  CheckAction(const QString&, QObject*);
+
+protected slots:
+
+protected:
+  bool checked;
+};
+
+inline bool CheckAction::isChecked() const {
+  return checked;
+}
+
+inline void CheckAction::setChecked(bool checked_) {
+  checked = checked_;
+  if(checked) setIcon(QIcon(":/16x16/item-check-on.png"));
+  else setIcon(QIcon(":/16x16/item-check-off.png"));
+}
+
+inline void CheckAction::toggleChecked() {
+  setChecked(!isChecked());
+}
+
+inline CheckAction::CheckAction(const QString &text, QObject *parent) : QAction(text, parent) {
+  setChecked(false);
+}
+
+}
+
+#endif

snesfilter/nall/qt/concept.hpp

@@ -0,0 +1,10 @@
+#ifndef NALL_QT_CONCEPT_HPP
+#define NALL_QT_CONCEPT_HPP
+
+#include <nall/concept.hpp>
+
+namespace nall {
+  template<typename T> struct has_count<QList<T>> { enum { value = true }; };
+}
+
+#endif

snesfilter/nall/qt/file-dialog.moc.hpp

@@ -0,0 +1,392 @@
+#ifndef NALL_QT_FILEDIALOG_HPP
+#define NALL_QT_FILEDIALOG_HPP
+
+#include <nall/platform.hpp>
+#include <nall/string.hpp>
+#include <nall/qt/window.moc.hpp>
+
+namespace nall {
+
+class FileDialog;
+
+class NewFolderDialog : public Window {
+  Q_OBJECT
+
+public:
+  void show();
+  NewFolderDialog(FileDialog*);
+
+protected slots:
+  void createFolderAction();
+
+protected:
+  FileDialog *parent;
+  QVBoxLayout *layout;
+  QLineEdit *folderNameEdit;
+  QHBoxLayout *controlLayout;
+  QPushButton *okButton;
+  QPushButton *cancelButton;
+};
+
+class FileView : public QListView {
+  Q_OBJECT
+
+protected:
+  void keyPressEvent(QKeyEvent*);
+
+signals:
+  void changed(const QModelIndex&);
+  void browseUp();
+
+protected slots:
+  void currentChanged(const QModelIndex&, const QModelIndex&);
+};
+
+class FileDialog : public Window {
+  Q_OBJECT
+
+public:
+  void showLoad();
+  void showSave();
+  void showFolder();
+
+  void setPath(string path);
+  void setNameFilters(const string &filters);
+  FileDialog();
+
+signals:
+  void changed(const string&);
+  void activated(const string&);
+  void accepted(const string&);
+  void rejected();
+
+protected slots:
+  void fileViewChange(const QModelIndex&);
+  void fileViewActivate(const QModelIndex&);
+  void pathBoxChanged();
+  void filterBoxChanged();
+  void createNewFolder();
+  void browseUp();
+  void acceptAction();
+  void rejectAction();
+
+protected:
+  NewFolderDialog *newFolderDialog;
+  QVBoxLayout *layout;
+  QHBoxLayout *navigationLayout;
+  QComboBox *pathBox;
+  QPushButton *newFolderButton;
+  QPushButton *upFolderButton;
+  QHBoxLayout *browseLayout;
+  QFileSystemModel *fileSystemModel;
+  FileView *fileView;
+  QGroupBox *previewFrame;
+  QLineEdit *fileNameEdit;
+  QHBoxLayout *controlLayout;
+  QComboBox *filterBox;
+  QPushButton *optionsButton;
+  QPushButton *acceptButton;
+  QPushButton *rejectButton;
+  bool lock;
+  void createFolderAction(const string &name);
+  void closeEvent(QCloseEvent*);
+
+  friend class NewFolderDialog;
+};
+
+inline void NewFolderDialog::show() {
+  folderNameEdit->setText("");
+  Window::show();
+  folderNameEdit->setFocus();
+}
+
+inline void NewFolderDialog::createFolderAction() {
+  string name = folderNameEdit->text().toUtf8().constData();
+  if(name == "") {
+    folderNameEdit->setFocus();
+  } else {
+    parent->createFolderAction(name);
+    close();
+  }
+}
+
+inline NewFolderDialog::NewFolderDialog(FileDialog *fileDialog) : parent(fileDialog) {
+  setMinimumWidth(240);
+  setWindowTitle("Create New Folder");
+
+  layout = new QVBoxLayout;
+  layout->setAlignment(Qt::AlignTop);
+  layout->setMargin(5);
+  layout->setSpacing(5);
+  setLayout(layout);
+
+  folderNameEdit = new QLineEdit;
+  layout->addWidget(folderNameEdit);
+
+  controlLayout = new QHBoxLayout;
+  controlLayout->setAlignment(Qt::AlignRight);
+  layout->addLayout(controlLayout);
+
+  okButton = new QPushButton("Ok");
+  controlLayout->addWidget(okButton);
+
+  cancelButton = new QPushButton("Cancel");
+  controlLayout->addWidget(cancelButton);
+
+  connect(folderNameEdit, SIGNAL(returnPressed()), this, SLOT(createFolderAction()));
+  connect(okButton, SIGNAL(released()), this, SLOT(createFolderAction()));
+  connect(cancelButton, SIGNAL(released()), this, SLOT(close()));
+}
+
+inline void FileView::currentChanged(const QModelIndex &current, const QModelIndex &previous) {
+  QAbstractItemView::currentChanged(current, previous);
+  emit changed(current);
+}
+
+inline void FileView::keyPressEvent(QKeyEvent *event) {
+  //enhance consistency: force OS X to act like Windows and Linux; enter = activate item
+  if(event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
+    emit activated(currentIndex());
+    return;
+  }
+
+  //simulate popular file manager behavior; backspace = go up one directory
+  if(event->key() == Qt::Key_Backspace) {
+    emit browseUp();
+    return;
+  }
+
+  //fallback: unrecognized keypresses get handled by the widget itself
+  QListView::keyPressEvent(event);
+}
+
+inline void FileDialog::showLoad() {
+  acceptButton->setText("Load");
+  fileNameEdit->hide();
+  filterBox->show();
+  show();
+}
+
+inline void FileDialog::showSave() {
+  acceptButton->setText("Save");
+  fileNameEdit->show();
+  filterBox->show();
+  show();
+}
+
+inline void FileDialog::showFolder() {
+  acceptButton->setText("Choose");
+  fileNameEdit->hide();
+  filterBox->hide();
+  setNameFilters("Folders ()");
+  show();
+}
+
+inline void FileDialog::fileViewChange(const QModelIndex &index) {
+  string path = fileSystemModel->filePath(index).toUtf8().constData();
+  if(path == fileSystemModel->rootPath().toUtf8().constData()) path = "";
+  fileNameEdit->setText(notdir(path));
+  emit changed(path);
+}
+
+inline void FileDialog::fileViewActivate(const QModelIndex &index) {
+  string path = fileSystemModel->filePath(index).toUtf8().constData();
+  if(fileSystemModel->isDir(index)) {
+    emit activated(path);
+    setPath(path);
+  } else {
+    emit activated(path);
+    close();
+  }
+}
+
+inline void FileDialog::pathBoxChanged() {
+  if(lock) return;
+  setPath(pathBox->currentText().toUtf8().constData());
+}
+
+inline void FileDialog::filterBoxChanged() {
+  if(lock) return;
+  string filters = filterBox->currentText().toUtf8().constData();
+  if(filters.length() == 0) {
+    fileSystemModel->setNameFilters(QStringList() << "*");
+  } else {
+    filters = substr(filters, strpos(filters, "(")());
+    ltrim(filters, "(");
+    rtrim(filters, ")");
+    lstring part;
+    part.split(" ", filters);
+    QStringList list;
+    for(unsigned i = 0; i < part.size(); i++) list << part[i];
+    fileSystemModel->setNameFilters(list);
+  }
+}
+
+inline void FileDialog::createNewFolder() {
+  newFolderDialog->show();
+}
+
+inline void FileDialog::browseUp() {
+  if(pathBox->count() > 1) pathBox->setCurrentIndex(1);
+}
+
+inline void FileDialog::setPath(string path) {
+  lock = true;
+  newFolderDialog->close();
+
+  if(QDir(path).exists()) {
+    newFolderButton->setEnabled(true);
+  } else {
+    newFolderButton->setEnabled(false);
+    path = "";
+  }
+
+  fileSystemModel->setRootPath(path);
+  fileView->setRootIndex(fileSystemModel->index(path));
+  fileView->setCurrentIndex(fileView->rootIndex());
+  fileView->setFocus();
+
+  pathBox->clear();
+  if(path.length() > 0) {
+    QDir directory(path);
+    while(true) {
+      pathBox->addItem(directory.absolutePath());
+      if(directory.isRoot()) break;
+      directory.cdUp();
+    }
+  }
+  pathBox->addItem("<root>");
+  fileNameEdit->setText("");
+
+  lock = false;
+}
+
+inline void FileDialog::setNameFilters(const string &filters) {
+  lock = true;
+
+  lstring list;
+  list.split("\n", filters);
+
+  filterBox->clear();
+  for(unsigned i = 0; i < list.size(); i++) {
+    filterBox->addItem(list[i]);
+  }
+
+  lock = false;
+  filterBoxChanged();
+}
+
+inline void FileDialog::acceptAction() {
+  string path = fileSystemModel->rootPath().toUtf8().constData();
+  path << "/" << notdir(fileNameEdit->text().toUtf8().constData());
+  rtrim(path, "/");
+  if(QDir(path).exists()) {
+    emit accepted(path);
+    setPath(path);
+  } else {
+    emit accepted(path);
+    close();
+  }
+}
+
+inline void FileDialog::rejectAction() {
+  emit rejected();
+  close();
+}
+
+inline void FileDialog::createFolderAction(const string &name) {
+  string path = fileSystemModel->rootPath().toUtf8().constData();
+  path << "/" << notdir(name);
+  mkdir(path, 0755);
+}
+
+inline void FileDialog::closeEvent(QCloseEvent *event) {
+  newFolderDialog->close();
+  Window::closeEvent(event);
+}
+
+inline FileDialog::FileDialog() {
+  newFolderDialog = new NewFolderDialog(this);
+  resize(640, 360);
+
+  layout = new QVBoxLayout;
+  layout->setMargin(5);
+  layout->setSpacing(5);
+  setLayout(layout);
+
+  navigationLayout = new QHBoxLayout;
+  layout->addLayout(navigationLayout);
+
+  pathBox = new QComboBox;
+  pathBox->setEditable(true);
+  pathBox->setMinimumContentsLength(16);
+  pathBox->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
+  pathBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+  navigationLayout->addWidget(pathBox);
+
+  newFolderButton = new QPushButton;
+  newFolderButton->setIconSize(QSize(16, 16));
+  newFolderButton->setIcon(QIcon(":/16x16/folder-new.png"));
+  navigationLayout->addWidget(newFolderButton);
+
+  upFolderButton = new QPushButton;
+  upFolderButton->setIconSize(QSize(16, 16));
+  upFolderButton->setIcon(QIcon(":/16x16/go-up.png"));
+  navigationLayout->addWidget(upFolderButton);
+
+  browseLayout = new QHBoxLayout;
+  layout->addLayout(browseLayout);
+
+  fileSystemModel = new QFileSystemModel;
+  fileSystemModel->setFilter(QDir::AllDirs | QDir::Files | QDir::NoDotAndDotDot);
+  fileSystemModel->setNameFilterDisables(false);
+
+  fileView = new FileView;
+  fileView->setMinimumWidth(320);
+  fileView->setModel(fileSystemModel);
+  fileView->setIconSize(QSize(16, 16));
+  browseLayout->addWidget(fileView);
+
+  previewFrame = new QGroupBox;
+  previewFrame->hide();
+  browseLayout->addWidget(previewFrame);
+
+  fileNameEdit = new QLineEdit;
+  layout->addWidget(fileNameEdit);
+
+  controlLayout = new QHBoxLayout;
+  controlLayout->setAlignment(Qt::AlignRight);
+  layout->addLayout(controlLayout);
+
+  filterBox = new QComboBox;
+  filterBox->setMinimumContentsLength(16);
+  filterBox->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
+  filterBox->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
+  controlLayout->addWidget(filterBox);
+
+  optionsButton = new QPushButton("Options");
+  optionsButton->hide();
+  controlLayout->addWidget(optionsButton);
+
+  acceptButton = new QPushButton("Ok");
+  controlLayout->addWidget(acceptButton);
+
+  rejectButton = new QPushButton("Cancel");
+  controlLayout->addWidget(rejectButton);
+
+  lock = false;
+  connect(pathBox, SIGNAL(currentIndexChanged(int)), this, SLOT(pathBoxChanged()));
+  connect(newFolderButton, SIGNAL(released()), this, SLOT(createNewFolder()));
+  connect(upFolderButton, SIGNAL(released()), this, SLOT(browseUp()));
+  connect(fileView, SIGNAL(changed(const QModelIndex&)), this, SLOT(fileViewChange(const QModelIndex&)));
+  connect(fileView, SIGNAL(activated(const QModelIndex&)), this, SLOT(fileViewActivate(const QModelIndex&)));
+  connect(fileView, SIGNAL(browseUp()), this, SLOT(browseUp()));
+  connect(fileNameEdit, SIGNAL(returnPressed()), this, SLOT(acceptAction()));
+  connect(filterBox, SIGNAL(currentIndexChanged(int)), this, SLOT(filterBoxChanged()));
+  connect(acceptButton, SIGNAL(released()), this, SLOT(acceptAction()));
+  connect(rejectButton, SIGNAL(released()), this, SLOT(rejectAction()));
+}
+
+}
+
+#endif

snesfilter/nall/qt/hex-editor.moc.hpp

@@ -0,0 +1,173 @@
+#ifndef NALL_QT_HEXEDITOR_HPP
+#define NALL_QT_HEXEDITOR_HPP
+
+#include <nall/function.hpp>
+#include <nall/stdint.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+class HexEditor : public QTextEdit {
+  Q_OBJECT
+
+public:
+  function<uint8_t (unsigned)> reader;
+  function<void (unsigned, uint8_t)> writer;
+
+  void setColumns(unsigned columns);
+  void setRows(unsigned rows);
+  void setOffset(unsigned offset);
+  void setSize(unsigned size);
+  unsigned lineWidth() const;
+  void refresh();
+
+  HexEditor();
+
+protected slots:
+  void scrolled();
+
+protected:
+  QHBoxLayout *layout;
+  QScrollBar *scrollBar;
+  unsigned editorColumns;
+  unsigned editorRows;
+  unsigned editorOffset;
+  unsigned editorSize;
+  bool lock;
+
+  void keyPressEvent(QKeyEvent*);
+};
+
+inline void HexEditor::keyPressEvent(QKeyEvent *event) {
+  QTextCursor cursor = textCursor();
+  unsigned x = cursor.position() % lineWidth();
+  unsigned y = cursor.position() / lineWidth();
+
+  int hexCode = -1;
+  switch(event->key()) {
+    case Qt::Key_0: hexCode =  0; break;
+    case Qt::Key_1: hexCode =  1; break;
+    case Qt::Key_2: hexCode =  2; break;
+    case Qt::Key_3: hexCode =  3; break;
+    case Qt::Key_4: hexCode =  4; break;
+    case Qt::Key_5: hexCode =  5; break;
+    case Qt::Key_6: hexCode =  6; break;
+    case Qt::Key_7: hexCode =  7; break;
+    case Qt::Key_8: hexCode =  8; break;
+    case Qt::Key_9: hexCode =  9; break;
+    case Qt::Key_A: hexCode = 10; break;
+    case Qt::Key_B: hexCode = 11; break;
+    case Qt::Key_C: hexCode = 12; break;
+    case Qt::Key_D: hexCode = 13; break;
+    case Qt::Key_E: hexCode = 14; break;
+    case Qt::Key_F: hexCode = 15; break;
+  }
+
+  if(cursor.hasSelection() == false && hexCode != -1) {
+    bool cursorOffsetValid = (x >= 11 && ((x - 11) % 3) != 2);
+    if(cursorOffsetValid) {
+      bool nibble = (x - 11) % 3;  //0 = top nibble, 1 = bottom nibble
+      unsigned cursorOffset = y * editorColumns + ((x - 11) / 3);
+      unsigned effectiveOffset = editorOffset + cursorOffset;
+      if(effectiveOffset >= editorSize) effectiveOffset %= editorSize;
+
+      uint8_t data = reader ? reader(effectiveOffset) : 0x00;
+      data &= (nibble == 0 ? 0x0f : 0xf0);
+      data |= (nibble == 0 ? (hexCode << 4) : (hexCode << 0));
+      if(writer) writer(effectiveOffset, data);
+      refresh();
+
+      cursor.setPosition(y * lineWidth() + x + 1);  //advance cursor
+      setTextCursor(cursor);
+    }
+  } else {
+    //allow navigation keys to move cursor, but block text input
+    setTextInteractionFlags(Qt::TextSelectableByKeyboard | Qt::TextSelectableByMouse);
+    QTextEdit::keyPressEvent(event);
+    setTextInteractionFlags(Qt::TextEditorInteraction);
+  }
+}
+
+inline void HexEditor::setColumns(unsigned columns) {
+  editorColumns = columns;
+}
+
+inline void HexEditor::setRows(unsigned rows) {
+  editorRows = rows;
+  scrollBar->setPageStep(editorRows);
+}
+
+inline void HexEditor::setOffset(unsigned offset) {
+  lock = true;
+  editorOffset = offset;
+  scrollBar->setSliderPosition(editorOffset / editorColumns);
+  lock = false;
+}
+
+inline void HexEditor::setSize(unsigned size) {
+  editorSize = size;
+  bool indivisible = (editorSize % editorColumns) != 0;  //add one for incomplete row
+  scrollBar->setRange(0, editorSize / editorColumns + indivisible - editorRows);
+}
+
+inline unsigned HexEditor::lineWidth() const {
+  return 11 + 3 * editorColumns;
+}
+
+inline void HexEditor::refresh() {
+  string output;
+  char temp[256];
+  unsigned offset = editorOffset;
+
+  for(unsigned y = 0; y < editorRows; y++) {
+    if(offset >= editorSize) break;
+    sprintf(temp, "%.4x:%.4x", (offset >> 16) & 0xffff, (offset >> 0) & 0xffff);
+    output << "<font color='#808080'>" << temp << "</font>&nbsp;&nbsp;";
+
+    for(unsigned x = 0; x < editorColumns; x++) {
+      if(offset >= editorSize) break;
+      sprintf(temp, "%.2x", reader ? reader(offset) : 0x00);
+      offset++;
+      output << "<font color='" << ((x & 1) ? "#000080" : "#0000ff") << "'>" << temp << "</font>";
+      if(x != (editorColumns - 1)) output << "&nbsp;";
+    }
+
+    if(y != (editorRows - 1)) output << "<br>";
+  }
+
+  setHtml(output);
+}
+
+inline void HexEditor::scrolled() {
+  if(lock) return;
+  unsigned offset = scrollBar->sliderPosition();
+  editorOffset = offset * editorColumns;
+  refresh();
+}
+
+inline HexEditor::HexEditor() {
+  setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+  setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
+
+  layout = new QHBoxLayout;
+  layout->setAlignment(Qt::AlignRight);
+  layout->setMargin(0);
+  layout->setSpacing(0);
+  setLayout(layout);
+
+  scrollBar = new QScrollBar(Qt::Vertical);
+  scrollBar->setSingleStep(1);
+  layout->addWidget(scrollBar);
+
+  lock = false;
+  connect(scrollBar, SIGNAL(actionTriggered(int)), this, SLOT(scrolled()));
+
+  setColumns(16);
+  setRows(16);
+  setSize(0);
+  setOffset(0);
+}
+
+}
+
+#endif

snesfilter/nall/qt/radio-action.moc.hpp

@@ -0,0 +1,41 @@
+#ifndef NALL_QT_RADIOACTION_HPP
+#define NALL_QT_RADIOACTION_HPP
+
+namespace nall {
+
+class RadioAction : public QAction {
+  Q_OBJECT
+
+public:
+  bool isChecked() const;
+  void setChecked(bool);
+  void toggleChecked();
+  RadioAction(const QString&, QObject*);
+
+protected slots:
+
+protected:
+  bool checked;
+};
+
+inline bool RadioAction::isChecked() const {
+  return checked;
+}
+
+inline void RadioAction::setChecked(bool checked_) {
+  checked = checked_;
+  if(checked) setIcon(QIcon(":/16x16/item-radio-on.png"));
+  else setIcon(QIcon(":/16x16/item-radio-off.png"));
+}
+
+inline void RadioAction::toggleChecked() {
+  setChecked(!isChecked());
+}
+
+inline RadioAction::RadioAction(const QString &text, QObject *parent) : QAction(text, parent) {
+  setChecked(false);
+}
+
+}
+
+#endif

snesfilter/nall/qt/window.moc.hpp

@@ -0,0 +1,105 @@
+#ifndef NALL_QT_WINDOW_HPP
+#define NALL_QT_WINDOW_HPP
+
+#include <nall/base64.hpp>
+#include <nall/string.hpp>
+
+namespace nall {
+
+class Window : public QWidget {
+  Q_OBJECT
+
+public:
+  void setGeometryString(string *geometryString);
+  void setCloseOnEscape(bool);
+  void show();
+  void hide();
+  void shrink();
+
+  Window();
+
+protected slots:
+
+protected:
+  string *geometryString;
+  bool closeOnEscape;
+  void keyReleaseEvent(QKeyEvent *event);
+  void closeEvent(QCloseEvent *event);
+};
+
+inline void Window::setGeometryString(string *geometryString_) {
+  geometryString = geometryString_;
+  if(geometryString && isVisible() == false) {
+    uint8_t *data;
+    unsigned length;
+    base64::decode(data, length, *geometryString);
+    QByteArray array((const char*)data, length);
+    delete[] data;
+    restoreGeometry(array);
+  }
+}
+
+inline void Window::setCloseOnEscape(bool value) {
+  closeOnEscape = value;
+}
+
+inline void Window::show() {
+  if(geometryString && isVisible() == false) {
+    uint8_t *data;
+    unsigned length;
+    base64::decode(data, length, *geometryString);
+    QByteArray array((const char*)data, length);
+    delete[] data;
+    restoreGeometry(array);
+  }
+  QWidget::show();
+  QApplication::processEvents();
+  activateWindow();
+  raise();
+}
+
+inline void Window::hide() {
+  if(geometryString && isVisible() == true) {
+    char *data;
+    QByteArray geometry = saveGeometry();
+    base64::encode(data, (const uint8_t*)geometry.data(), geometry.length());
+    *geometryString = data;
+    delete[] data;
+  }
+  QWidget::hide();
+}
+
+inline void Window::shrink() {
+  if(isFullScreen()) return;
+
+  for(unsigned i = 0; i < 2; i++) {
+    resize(0, 0);
+    usleep(2000);
+    QApplication::processEvents();
+  }
+}
+
+inline void Window::keyReleaseEvent(QKeyEvent *event) {
+  if(closeOnEscape && (event->key() == Qt::Key_Escape)) close();
+  QWidget::keyReleaseEvent(event);
+}
+
+inline void Window::closeEvent(QCloseEvent *event) {
+  if(geometryString) {
+    char *data;
+    QByteArray geometry = saveGeometry();
+    base64::encode(data, (const uint8_t*)geometry.data(), geometry.length());
+    *geometryString = data;
+    delete[] data;
+  }
+  QWidget::closeEvent(event);
+}
+
+inline Window::Window() {
+  geometryString = 0;
+  closeOnEscape = true;
+}
+
+}
+
+#endif

snesfilter/nall/random.hpp

@@ -0,0 +1,20 @@
+#ifndef NALL_RANDOM_HPP
+#define NALL_RANDOM_HPP
+
+namespace nall {
+  //pseudo-random number generator
+  inline unsigned prng() {
+    static unsigned n = 0;
+    return n = (n >> 1) ^ (((n & 1) - 1) & 0xedb88320);
+  }
+
+  struct random_cyclic {
+    unsigned seed;
+    inline unsigned operator()() {
+      return seed = (seed >> 1) ^ (((seed & 1) - 1) & 0xedb88320);
+    }
+    random_cyclic() : seed(0) {}
+  };
+}
+
+#endif

snesfilter/nall/serializer.hpp

@@ -0,0 +1,145 @@
+#ifndef NALL_SERIALIZER_HPP
+#define NALL_SERIALIZER_HPP
+
+#include <type_traits>
+#include <utility>
+#include <nall/stdint.hpp>
+#include <nall/utility.hpp>
+
+namespace nall {
+  //serializer: a class designed to save and restore the state of classes.
+  //
+  //benefits:
+  //- data() will be portable in size (it is not necessary to specify type sizes.)
+  //- data() will be portable in endianness (always stored internally as little-endian.)
+  //- one serialize function can both save and restore class states.
+  //
+  //caveats:
+  //- only plain-old-data can be stored. complex classes must provide serialize(serializer&);
+  //- floating-point usage is not portable across platforms
+
+  class serializer {
+  public:
+    enum mode_t { Load, Save, Size };
+
+    mode_t mode() const {
+      return imode;
+    }
+
+    const uint8_t* data() const {
+      return idata;
+    }
+
+    unsigned size() const {
+      return isize;
+    }
+
+    unsigned capacity() const {
+      return icapacity;
+    }
+
+    template<typename T> void floatingpoint(T &value) {
+      enum { size = sizeof(T) };
+      //this is rather dangerous, and not cross-platform safe;
+      //but there is no standardized way to export FP-values
+      uint8_t *p = (uint8_t*)&value;
+      if(imode == Save) {
+        for(unsigned n = 0; n < size; n++) idata[isize++] = p[n];
+      } else if(imode == Load) {
+        for(unsigned n = 0; n < size; n++) p[n] = idata[isize++];
+      } else {
+        isize += size;
+      }
+    }
+
+    template<typename T> void integer(T &value) {
+      enum { size = std::is_same<bool, T>::value ? 1 : sizeof(T) };
+      if(imode == Save) {
+        for(unsigned n = 0; n < size; n++) idata[isize++] = value >> (n << 3);
+      } else if(imode == Load) {
+        value = 0;
+        for(unsigned n = 0; n < size; n++) value |= idata[isize++] << (n << 3);
+      } else if(imode == Size) {
+        isize += size;
+      }
+    }
+
+    template<typename T> void array(T &array) {
+      enum { size = sizeof(T) / sizeof(typename std::remove_extent<T>::type) };
+      for(unsigned n = 0; n < size; n++) integer(array[n]);
+    }
+
+    template<typename T> void array(T array, unsigned size) {
+      for(unsigned n = 0; n < size; n++) integer(array[n]);
+    }
+
+    //copy
+    serializer& operator=(const serializer &s) {
+      if(idata) delete[] idata;
+
+      imode = s.imode;
+      idata = new uint8_t[s.icapacity];
+      isize = s.isize;
+      icapacity = s.icapacity;
+
+      memcpy(idata, s.idata, s.icapacity);
+      return *this;
+    }
+
+    serializer(const serializer &s) : idata(0) {
+      operator=(s);
+    }
+
+    //move
+    serializer& operator=(serializer &&s) {
+      if(idata) delete[] idata;
+
+      imode = s.imode;
+      idata = s.idata;
+      isize = s.isize;
+      icapacity = s.icapacity;
+
+      s.idata = 0;
+      return *this;
+    }
+
+    serializer(serializer &&s) {
+      operator=(std::move(s));
+    }
+
+    //construction
+    serializer() {
+      imode = Size;
+      idata = 0;
+      isize = 0;
+    }
+
+    serializer(unsigned capacity) {
+      imode = Save;
+      idata = new uint8_t[capacity]();
+      isize = 0;
+      icapacity = capacity;
+    }
+
+    serializer(const uint8_t *data, unsigned capacity) {
+      imode = Load;
+      idata = new uint8_t[capacity];
+      isize = 0;
+      icapacity = capacity;
+      memcpy(idata, data, capacity);
+    }
+
+    ~serializer() {
+      if(idata) delete[] idata;
+    }
+
+  private:
+    mode_t imode;
+    uint8_t *idata;
+    unsigned isize;
+    unsigned icapacity;
+  };
+
+};
+
+#endif

snesfilter/nall/sha256.hpp

@@ -0,0 +1,143 @@
+#ifndef NALL_SHA256_HPP
+#define NALL_SHA256_HPP
+
+//author: vladitx
+
+namespace nall {
+  #define PTR(t, a) ((t*)(a))
+
+  #define SWAP32(x) ((uint32_t)(           \
+    (((uint32_t)(x) & 0x000000ff) << 24) | \
+    (((uint32_t)(x) & 0x0000ff00) <<  8) | \
+    (((uint32_t)(x) & 0x00ff0000) >>  8) | \
+    (((uint32_t)(x) & 0xff000000) >> 24)   \
+  ))
+
+  #define ST32(a, d) *PTR(uint32_t, a) = (d)
+  #define ST32BE(a, d) ST32(a, SWAP32(d))
+
+  #define LD32(a) *PTR(uint32_t, a)
+  #define LD32BE(a) SWAP32(LD32(a))
+
+  #define LSL32(x, n) ((uint32_t)(x) << (n))
+  #define LSR32(x, n) ((uint32_t)(x) >> (n))
+  #define ROR32(x, n) (LSR32(x, n) | LSL32(x, 32 - (n)))
+
+  //first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19
+  static const uint32_t T_H[8] = {
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+  };
+
+  //first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311
+  static const uint32_t T_K[64] = {
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+  };
+
+  struct sha256_ctx {
+    uint8_t in[64];
+    unsigned inlen;
+
+    uint32_t w[64];
+    uint32_t h[8];
+    uint64_t len;
+  };
+
+  void sha256_init(sha256_ctx *p) {
+    memset(p, 0, sizeof(sha256_ctx));
+    memcpy(p->h, T_H, sizeof(T_H));
+  }
+
+  static void sha256_block(sha256_ctx *p) {
+    unsigned i;
+    uint32_t s0, s1;
+    uint32_t a, b, c, d, e, f, g, h;
+    uint32_t t1, t2, maj, ch;
+
+    for(i = 0; i < 16; i++) p->w[i] = LD32BE(p->in + i * 4);
+
+    for(i = 16; i < 64; i++) {
+      s0 = ROR32(p->w[i - 15],  7) ^ ROR32(p->w[i - 15], 18) ^ LSR32(p->w[i - 15],  3);
+      s1 = ROR32(p->w[i -  2], 17) ^ ROR32(p->w[i -  2], 19) ^ LSR32(p->w[i -  2], 10);
+      p->w[i] = p->w[i - 16] + s0 + p->w[i - 7] + s1;
+    }
+
+    a = p->h[0]; b = p->h[1]; c = p->h[2]; d = p->h[3];
+    e = p->h[4]; f = p->h[5]; g = p->h[6]; h = p->h[7];
+
+    for(i = 0; i < 64; i++) {
+      s0 = ROR32(a, 2) ^ ROR32(a, 13) ^ ROR32(a, 22);
+      maj = (a & b) ^ (a & c) ^ (b & c);
+      t2 = s0 + maj;
+      s1 = ROR32(e, 6) ^ ROR32(e, 11) ^ ROR32(e, 25);
+      ch = (e & f) ^ (~e & g);
+      t1 = h + s1 + ch + T_K[i] + p->w[i];
+
+      h = g; g = f; f = e; e = d + t1;
+      d = c; c = b; b = a; a = t1 + t2;
+    }
+
+    p->h[0] += a; p->h[1] += b; p->h[2] += c; p->h[3] += d;
+    p->h[4] += e; p->h[5] += f; p->h[6] += g; p->h[7] += h;
+
+    //next block
+    p->inlen = 0;
+  }
+
+  void sha256_chunk(sha256_ctx *p, const uint8_t *s, unsigned len) {
+    unsigned l;
+    p->len += len;
+
+    while(len) {
+      l = 64 - p->inlen;
+      l = (len < l) ? len : l;
+
+      memcpy(p->in + p->inlen, s, l);
+      s += l;
+      p->inlen += l;
+      len -= l;
+
+      if(p->inlen == 64) sha256_block(p);
+    }
+  }
+
+  void sha256_final(sha256_ctx *p) {
+    uint64_t len;
+    p->in[p->inlen++] = 0x80;
+
+    if(p->inlen > 56) {
+      memset(p->in + p->inlen, 0, 64 - p->inlen);
+      sha256_block(p);
+    }
+
+    memset(p->in + p->inlen, 0, 56 - p->inlen);
+
+    len = p->len << 3;
+    ST32BE(p->in + 56, len >> 32);
+    ST32BE(p->in + 60, len);
+    sha256_block(p);
+  }
+
+  void sha256_hash(sha256_ctx *p, uint8_t *s) {
+    uint32_t *t = (uint32_t*)s;
+    for(unsigned i = 0; i < 8; i++) ST32BE(t++, p->h[i]);
+  }
+
+  #undef PTR
+  #undef SWAP32
+  #undef ST32
+  #undef ST32BE
+  #undef LD32
+  #undef LD32BE
+  #undef LSL32
+  #undef LSR32
+  #undef ROR32
+}
+
+#endif

snesfilter/nall/snes/info.hpp

@@ -0,0 +1,864 @@
+#ifndef NALL_SNES_INFO_HPP
+#define NALL_SNES_INFO_HPP
+
+namespace nall {
+
+class snes_information {
+public:
+  string xml_memory_map;
+
+  inline snes_information(const uint8_t *data, unsigned size);
+
+private:
+  inline void read_header(const uint8_t *data, unsigned size);
+  inline unsigned find_header(const uint8_t *data, unsigned size);
+  inline unsigned score_header(const uint8_t *data, unsigned size, unsigned addr);
+  inline unsigned gameboy_ram_size(const uint8_t *data, unsigned size);
+  inline bool gameboy_has_rtc(const uint8_t *data, unsigned size);
+
+  enum HeaderField {
+    CartName    = 0x00,
+    Mapper      = 0x15,
+    RomType     = 0x16,
+    RomSize     = 0x17,
+    RamSize     = 0x18,
+    CartRegion  = 0x19,
+    Company     = 0x1a,
+    Version     = 0x1b,
+    Complement  = 0x1c,  //inverse checksum
+    Checksum    = 0x1e,
+    ResetVector = 0x3c,
+  };
+
+  enum Mode {
+    ModeNormal,
+    ModeBsxSlotted,
+    ModeBsx,
+    ModeSufamiTurbo,
+    ModeSuperGameBoy,
+  };
+
+  enum Type {
+    TypeNormal,
+    TypeBsxSlotted,
+    TypeBsxBios,
+    TypeBsx,
+    TypeSufamiTurboBios,
+    TypeSufamiTurbo,
+    TypeSuperGameBoy1Bios,
+    TypeSuperGameBoy2Bios,
+    TypeGameBoy,
+    TypeUnknown,
+  };
+
+  enum Region {
+    NTSC,
+    PAL,
+  };
+
+  enum MemoryMapper {
+    LoROM,
+    HiROM,
+    ExLoROM,
+    ExHiROM,
+    SuperFXROM,
+    SA1ROM,
+    SPC7110ROM,
+    BSCLoROM,
+    BSCHiROM,
+    BSXROM,
+    STROM,
+  };
+
+  enum DSP1MemoryMapper {
+    DSP1Unmapped,
+    DSP1LoROM1MB,
+    DSP1LoROM2MB,
+    DSP1HiROM,
+  };
+
+  bool loaded;        //is a base cartridge inserted?
+  unsigned crc32;     //crc32 of all cartridges (base+slot(s))
+  unsigned rom_size;
+  unsigned ram_size;
+
+  Mode mode;
+  Type type;
+  Region region;
+  MemoryMapper mapper;
+  DSP1MemoryMapper dsp1_mapper;
+
+  bool has_bsx_slot;
+  bool has_superfx;
+  bool has_sa1;
+  bool has_srtc;
+  bool has_sdd1;
+  bool has_spc7110;
+  bool has_spc7110rtc;
+  bool has_cx4;
+  bool has_dsp1;
+  bool has_dsp2;
+  bool has_dsp3;
+  bool has_dsp4;
+  bool has_obc1;
+  bool has_st010;
+  bool has_st011;
+  bool has_st018;
+};
+
+snes_information::snes_information(const uint8_t *data, unsigned size) {
+  read_header(data, size);
+
+  string xml = "<?xml version='1.0' encoding='UTF-8'?>\n";
+
+  if(type == TypeBsx) {
+    xml << "<cartridge/>";
+    xml_memory_map = xml;
+    return;
+  }
+
+  if(type == TypeSufamiTurbo) {
+    xml << "<cartridge/>";
+    xml_memory_map = xml;
+    return;
+  }
+
+  if(type == TypeGameBoy) {
+    xml << "<cartridge rtc='" << gameboy_has_rtc(data, size) << "'>\n";
+    if(gameboy_ram_size(data, size) > 0) {
+      xml << "  <ram size='" << strhex(gameboy_ram_size(data, size)) << "'/>\n";
+    }
+    xml << "</cartridge>\n";
+    xml_memory_map = xml;
+    return;
+  }
+
+  xml << "<cartridge";
+  if(region == NTSC) {
+    xml << " region='NTSC'";
+  } else {
+    xml << " region='PAL'";
+  }
+  xml << ">\n";
+
+  if(type == TypeSuperGameBoy1Bios) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <supergameboy revision='1'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </supergameboy>\n";
+  } else if(type == TypeSuperGameBoy2Bios) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <supergameboy revision='2'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </supergameboy>\n";
+  } else if(has_spc7110) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-0f:8000-ffff'/>\n";
+    xml << "    <map mode='shadow' address='80-bf:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='c0-cf:0000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    xml << "  <spc7110>\n";
+    xml << "    <mcu>\n";
+    xml << "      <map address='d0-ff:0000-ffff' offset='100000' size='" << strhex(size - 0x100000) << "'/>\n";
+    xml << "    </mcu>\n";
+    xml << "    <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "      <map mode='linear' address='00:6000-7fff'/>\n";
+    xml << "      <map mode='linear' address='30:6000-7fff'/>\n";
+    xml << "    </ram>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:4800-483f'/>\n";
+    xml << "      <map address='80-bf:4800-483f'/>\n";
+    xml << "    </mmio>\n";
+    if(has_spc7110rtc) {
+      xml << "    <rtc>\n";
+      xml << "      <map address='00-3f:4840-4842'/>\n";
+      xml << "      <map address='80-bf:4840-4842'/>\n";
+      xml << "    </rtc>\n";
+    }
+    xml << "    <dcu>\n";
+    xml << "      <map address='50:0000-ffff'/>\n";
+    xml << "    </dcu>\n";
+    xml << "  </spc7110>\n";
+  } else if(mapper == LoROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-7f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-ff:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
+        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+        xml << "    <map mode='linear' address='f0-ff:0000-7fff'/>\n";
+      } else {
+        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
+        xml << "    <map mode='linear' address='f0-ff:0000-ffff'/>\n";
+      }
+      xml << "  </ram>\n";
+    }
+  } else if(mapper == HiROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-3f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='40-7f:0000-ffff'/>\n";
+    xml << "    <map mode='shadow' address='80-bf:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='c0-ff:0000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
+        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+      } else {
+        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
+      }
+      xml << "  </ram>\n";
+    }
+  } else if(mapper == ExLoROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='40-7f:0000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+      xml << "  </ram>\n";
+    }
+  } else if(mapper == ExHiROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-3f:8000-ffff' offset='400000'/>\n";
+    xml << "    <map mode='linear' address='40-7f:0000-ffff' offset='400000'/>\n";
+    xml << "    <map mode='shadow' address='80-bf:8000-ffff' offset='000000'/>\n";
+    xml << "    <map mode='linear' address='c0-ff:0000-ffff' offset='000000'/>\n";
+    xml << "  </rom>\n";
+
+    if(ram_size > 0) {
+      xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+      xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+      xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+      if((rom_size > 0x200000) || (ram_size > 32 * 1024)) {
+        xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+      } else {
+        xml << "    <map mode='linear' address='70-7f:0000-ffff'/>\n";
+      }
+      xml << "  </ram>\n";
+    }
+  } else if(mapper == SuperFXROM) {
+    xml << "  <superfx revision='2'>\n";
+    xml << "    <rom>\n";
+    xml << "      <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='40-5f:0000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='c0-df:0000-ffff'/>\n";
+    xml << "    </rom>\n";
+    xml << "    <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "      <map mode='linear' address='00-3f:6000-7fff' size='2000'/>\n";
+    xml << "      <map mode='linear' address='60-7f:0000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:6000-7fff' size='2000'/>\n";
+    xml << "      <map mode='linear' address='e0-ff:0000-ffff'/>\n";
+    xml << "    </ram>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:3000-32ff'/>\n";
+    xml << "      <map address='80-bf:3000-32ff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </superfx>\n";
+  } else if(mapper == SA1ROM) {
+    xml << "  <sa1>\n";
+    xml << "    <rom>\n";
+    xml << "      <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='c0-ff:0000-ffff'/>\n";
+    xml << "    </rom>\n";
+    xml << "    <iram size='800'>\n";
+    xml << "      <map mode='linear' address='00-3f:3000-37ff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:3000-37ff'/>\n";
+    xml << "    </iram>\n";
+    xml << "    <bwram size='" << strhex(ram_size) << "'>\n";
+    xml << "      <map mode='linear' address='00-3f:6000-7fff'/>\n";
+    xml << "      <map mode='linear' address='40-4f:0000-ffff'/>\n";
+    xml << "      <map mode='linear' address='80-bf:6000-7fff'/>\n";
+    xml << "    </bwram>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:2200-23ff'/>\n";
+    xml << "      <map address='80-bf:2200-23ff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </sa1>\n";
+  } else if(mapper == BSCLoROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-1f:8000-ffff' offset='000000'/>\n";
+    xml << "    <map mode='linear' address='20-3f:8000-ffff' offset='100000'/>\n";
+    xml << "    <map mode='linear' address='80-9f:8000-ffff' offset='200000'/>\n";
+    xml << "    <map mode='linear' address='a0-bf:8000-ffff' offset='100000'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "    <map mode='linear' address='70-7f:0000-7fff'/>\n";
+    xml << "    <map mode='linear' address='f0-ff:0000-7fff'/>\n";
+    xml << "  </ram>\n";
+    xml << "  <bsx>\n";
+    xml << "    <slot>\n";
+    xml << "      <map mode='linear' address='c0-ef:0000-ffff'/>\n";
+    xml << "    </slot>\n";
+    xml << "  </bsx>\n";
+  } else if(mapper == BSCHiROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='shadow' address='00-1f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='40-5f:0000-ffff'/>\n";
+    xml << "    <map mode='shadow' address='80-9f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='c0-df:0000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <ram size='" << strhex(ram_size) << "'>\n";
+    xml << "    <map mode='linear' address='20-3f:6000-7fff'/>\n";
+    xml << "    <map mode='linear' address='a0-bf:6000-7fff'/>\n";
+    xml << "  </ram>\n";
+    xml << "  <bsx>\n";
+    xml << "    <slot>\n";
+    xml << "      <map mode='shadow' address='20-3f:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='60-7f:0000-ffff'/>\n";
+    xml << "      <map mode='shadow' address='a0-bf:8000-ffff'/>\n";
+    xml << "      <map mode='linear' address='e0-ff:0000-ffff'/>\n";
+    xml << "    </slot>\n";
+    xml << "  </bsx>\n";
+  } else if(mapper == BSXROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-3f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-bf:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <bsx>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:5000-5fff'/>\n";
+    xml << "      <map address='80-bf:5000-5fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </bsx>\n";
+  } else if(mapper == STROM) {
+    xml << "  <rom>\n";
+    xml << "    <map mode='linear' address='00-1f:8000-ffff'/>\n";
+    xml << "    <map mode='linear' address='80-9f:8000-ffff'/>\n";
+    xml << "  </rom>\n";
+    xml << "  <sufamiturbo>\n";
+    xml << "    <slot id='A'>\n";
+    xml << "      <rom>\n";
+    xml << "        <map mode='linear' address='20-3f:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='a0-bf:8000-ffff'/>\n";
+    xml << "      </rom>\n";
+    xml << "      <ram>\n";
+    xml << "        <map mode='linear' address='60-63:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='e0-e3:8000-ffff'/>\n";
+    xml << "      </ram>\n";
+    xml << "    </slot>\n";
+    xml << "    <slot id='B'>\n";
+    xml << "      <rom>\n";
+    xml << "        <map mode='linear' address='40-5f:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='c0-df:8000-ffff'/>\n";
+    xml << "      </rom>\n";
+    xml << "      <ram>\n";
+    xml << "        <map mode='linear' address='70-73:8000-ffff'/>\n";
+    xml << "        <map mode='linear' address='f0-f3:8000-ffff'/>\n";
+    xml << "      </ram>\n";
+    xml << "    </slot>\n";
+    xml << "  </sufamiturbo>\n";
+  }
+
+  if(has_srtc) {
+    xml << "  <srtc>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:2800-2801'/>\n";
+    xml << "      <map address='80-bf:2800-2801'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </srtc>\n";
+  }
+
+  if(has_sdd1) {
+    xml << "  <sdd1>\n";
+    xml << "    <mcu>\n";
+    xml << "      <map address='c0-ff:0000-ffff'/>\n";
+    xml << "    </mcu>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:4800-4807'/>\n";
+    xml << "      <map address='80-bf:4800-4807'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </sdd1>\n";
+  }
+
+  if(has_cx4) {
+    xml << "  <cx4>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </cx4>\n";
+  }
+
+  if(has_dsp1) {
+    xml << "  <necdsp program='DSP-1B'>\n";
+    if(dsp1_mapper == DSP1LoROM1MB) {
+      xml << "    <dr>\n";
+      xml << "      <map address='20-3f:8000-bfff'/>\n";
+      xml << "      <map address='a0-bf:8000-bfff'/>\n";
+      xml << "    </dr>\n";
+      xml << "    <sr>\n";
+      xml << "      <map address='20-3f:c000-ffff'/>\n";
+      xml << "      <map address='a0-bf:c000-ffff'/>\n";
+      xml << "    </sr>\n";
+    } else if(dsp1_mapper == DSP1LoROM2MB) {
+      xml << "    <dr>\n";
+      xml << "      <map address='60-6f:0000-3fff'/>\n";
+      xml << "      <map address='e0-ef:0000-3fff'/>\n";
+      xml << "    </dr>\n";
+      xml << "    <sr>\n";
+      xml << "      <map address='60-6f:4000-7fff'/>\n";
+      xml << "      <map address='e0-ef:4000-7fff'/>\n";
+      xml << "    </sr>\n";
+    } else if(dsp1_mapper == DSP1HiROM) {
+      xml << "    <dr>\n";
+      xml << "      <map address='00-1f:6000-6fff'/>\n";
+      xml << "      <map address='80-9f:6000-6fff'/>\n";
+      xml << "    </dr>\n";
+      xml << "    <sr>\n";
+      xml << "      <map address='00-1f:7000-7fff'/>\n";
+      xml << "      <map address='80-9f:7000-7fff'/>\n";
+      xml << "    </sr>\n";
+    }
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_dsp2) {
+    xml << "  <necdsp program='DSP-2'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='20-3f:8000-bfff'/>\n";
+    xml << "      <map address='a0-bf:8000-bfff'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='20-3f:c000-ffff'/>\n";
+    xml << "      <map address='a0-bf:c000-ffff'/>\n";
+    xml << "    </sr>\n";
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_dsp3) {
+    xml << "  <necdsp program='DSP-3'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='20-3f:8000-bfff'/>\n";
+    xml << "      <map address='a0-bf:8000-bfff'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='20-3f:c000-ffff'/>\n";
+    xml << "      <map address='a0-bf:c000-ffff'/>\n";
+    xml << "    </sr>\n";
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_dsp4) {
+    xml << "  <necdsp program='DSP-4'>\n";
+    xml << "    <dr>\n";
+    xml << "      <map address='30-3f:8000-bfff'/>\n";
+    xml << "      <map address='b0-bf:8000-bfff'/>\n";
+    xml << "    </dr>\n";
+    xml << "    <sr>\n";
+    xml << "      <map address='30-3f:c000-ffff'/>\n";
+    xml << "      <map address='b0-bf:c000-ffff'/>\n";
+    xml << "    </sr>\n";
+    xml << "  </necdsp>\n";
+  }
+
+  if(has_obc1) {
+    xml << "  <obc1>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:6000-7fff'/>\n";
+    xml << "      <map address='80-bf:6000-7fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </obc1>\n";
+  }
+
+  if(has_st010) {
+    xml << "  <setadsp program='ST-0010'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='68-6f:0000-0fff'/>\n";
+    xml << "      <map address='e8-ef:0000-0fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </setadsp>\n";
+  }
+
+  if(has_st011) {
+    //ST-0011 addresses not verified; chip is unsupported
+    xml << "  <setadsp program='ST-0011'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='68-6f:0000-0fff'/>\n";
+    xml << "      <map address='e8-ef:0000-0fff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </setadsp>\n";
+  }
+
+  if(has_st018) {
+    xml << "  <setarisc program='ST-0018'>\n";
+    xml << "    <mmio>\n";
+    xml << "      <map address='00-3f:3800-38ff'/>\n";
+    xml << "      <map address='80-bf:3800-38ff'/>\n";
+    xml << "    </mmio>\n";
+    xml << "  </setarisc>\n";
+  }
+
+  xml << "</cartridge>\n";
+  xml_memory_map = xml;
+}
+
+void snes_information::read_header(const uint8_t *data, unsigned size) {
+  type        = TypeUnknown;
+  mapper      = LoROM;
+  dsp1_mapper = DSP1Unmapped;
+  region      = NTSC;
+  rom_size    = size;
+  ram_size    = 0;
+
+  has_bsx_slot   = false;
+  has_superfx    = false;
+  has_sa1        = false;
+  has_srtc       = false;
+  has_sdd1       = false;
+  has_spc7110    = false;
+  has_spc7110rtc = false;
+  has_cx4        = false;
+  has_dsp1       = false;
+  has_dsp2       = false;
+  has_dsp3       = false;
+  has_dsp4       = false;
+  has_obc1       = false;
+  has_st010      = false;
+  has_st011      = false;
+  has_st018      = false;
+
+  //=====================
+  //detect Game Boy carts
+  //=====================
+
+  if(size >= 0x0140) {
+    if(data[0x0104] == 0xce && data[0x0105] == 0xed && data[0x0106] == 0x66 && data[0x0107] == 0x66
+    && data[0x0108] == 0xcc && data[0x0109] == 0x0d && data[0x010a] == 0x00 && data[0x010b] == 0x0b) {
+      type = TypeGameBoy;
+      return;
+    }
+  }
+
+  const unsigned index = find_header(data, size);
+  const uint8_t mapperid = data[index + Mapper];
+  const uint8_t rom_type = data[index + RomType];
+  const uint8_t rom_size = data[index + RomSize];
+  const uint8_t company  = data[index + Company];
+  const uint8_t regionid = data[index + CartRegion] & 0x7f;
+
+  ram_size = 1024 << (data[index + RamSize] & 7);
+  if(ram_size == 1024) ram_size = 0;  //no RAM present
+
+  //0, 1, 13 = NTSC; 2 - 12 = PAL
+  region = (regionid <= 1 || regionid >= 13) ? NTSC : PAL;
+
+  //=======================
+  //detect BS-X flash carts
+  //=======================
+
+  if(data[index + 0x13] == 0x00 || data[index + 0x13] == 0xff) {
+    if(data[index + 0x14] == 0x00) {
+      const uint8_t n15 = data[index + 0x15];
+      if(n15 == 0x00 || n15 == 0x80 || n15 == 0x84 || n15 == 0x9c || n15 == 0xbc || n15 == 0xfc) {
+        if(data[index + 0x1a] == 0x33 || data[index + 0x1a] == 0xff) {
+          type = TypeBsx;
+          mapper = BSXROM;
+          region = NTSC;  //BS-X only released in Japan
+          return;
+        }
+      }
+    }
+  }
+
+  //=========================
+  //detect Sufami Turbo carts
+  //=========================
+
+  if(!memcmp(data, "BANDAI SFC-ADX", 14)) {
+    if(!memcmp(data + 16, "SFC-ADX BACKUP", 14)) {
+      type = TypeSufamiTurboBios;
+    } else {
+      type = TypeSufamiTurbo;
+    }
+    mapper = STROM;
+    region = NTSC;  //Sufami Turbo only released in Japan
+    return;         //RAM size handled outside this routine
+  }
+
+  //==========================
+  //detect Super Game Boy BIOS
+  //==========================
+
+  if(!memcmp(data + index, "Super GAMEBOY2", 14)) {
+    type = TypeSuperGameBoy2Bios;
+    return;
+  }
+
+  if(!memcmp(data + index, "Super GAMEBOY", 13)) {
+    type = TypeSuperGameBoy1Bios;
+    return;
+  }
+
+  //=====================
+  //detect standard carts
+  //=====================
+
+  //detect presence of BS-X flash cartridge connector (reads extended header information)
+  if(data[index - 14] == 'Z') {
+    if(data[index - 11] == 'J') {
+      uint8_t n13 = data[index - 13];
+      if((n13 >= 'A' && n13 <= 'Z') || (n13 >= '0' && n13 <= '9')) {
+        if(company == 0x33 || (data[index - 10] == 0x00 && data[index - 4] == 0x00)) {
+          has_bsx_slot = true;
+        }
+      }
+    }
+  }
+
+  if(has_bsx_slot) {
+    if(!memcmp(data + index, "Satellaview BS-X     ", 21)) {
+      //BS-X base cart
+      type = TypeBsxBios;
+      mapper = BSXROM;
+      region = NTSC;  //BS-X only released in Japan
+      return;         //RAM size handled internally by load_cart_bsx() -> BSXCart class
+    } else {
+      type = TypeBsxSlotted;
+      mapper = (index == 0x7fc0 ? BSCLoROM : BSCHiROM);
+      region = NTSC;  //BS-X slotted cartridges only released in Japan
+    }
+  } else {
+    //standard cart
+    type = TypeNormal;
+
+    if(index == 0x7fc0 && size >= 0x401000) {
+      mapper = ExLoROM;
+    } else if(index == 0x7fc0 && mapperid == 0x32) {
+      mapper = ExLoROM;
+    } else if(index == 0x7fc0) {
+      mapper = LoROM;
+    } else if(index == 0xffc0) {
+      mapper = HiROM;
+    } else {  //index == 0x40ffc0
+      mapper = ExHiROM;
+    }
+  }
+
+  if(mapperid == 0x20 && (rom_type == 0x13 || rom_type == 0x14 || rom_type == 0x15 || rom_type == 0x1a)) {
+    has_superfx = true;
+    mapper = SuperFXROM;
+    ram_size = 1024 << (data[index - 3] & 7);
+    if(ram_size == 1024) ram_size = 0;
+  }
+
+  if(mapperid == 0x23 && (rom_type == 0x32 || rom_type == 0x34 || rom_type == 0x35)) {
+    has_sa1 = true;
+    mapper = SA1ROM;
+  }
+
+  if(mapperid == 0x35 && rom_type == 0x55) {
+    has_srtc = true;
+  }
+
+  if(mapperid == 0x32 && (rom_type == 0x43 || rom_type == 0x45)) {
+    has_sdd1 = true;
+  }
+
+  if(mapperid == 0x3a && (rom_type == 0xf5 || rom_type == 0xf9)) {
+    has_spc7110 = true;
+    has_spc7110rtc = (rom_type == 0xf9);
+    mapper = SPC7110ROM;
+  }
+
+  if(mapperid == 0x20 && rom_type == 0xf3) {
+    has_cx4 = true;
+  }
+
+  if((mapperid == 0x20 || mapperid == 0x21) && rom_type == 0x03) {
+    has_dsp1 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x05 && company != 0xb2) {
+    has_dsp1 = true;
+  }
+
+  if(mapperid == 0x31 && (rom_type == 0x03 || rom_type == 0x05)) {
+    has_dsp1 = true;
+  }
+
+  if(has_dsp1 == true) {
+    if((mapperid & 0x2f) == 0x20 && size <= 0x100000) {
+      dsp1_mapper = DSP1LoROM1MB;
+    } else if((mapperid & 0x2f) == 0x20) {
+      dsp1_mapper = DSP1LoROM2MB;
+    } else if((mapperid & 0x2f) == 0x21) {
+      dsp1_mapper = DSP1HiROM;
+    }
+  }
+
+  if(mapperid == 0x20 && rom_type == 0x05) {
+    has_dsp2 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x05 && company == 0xb2) {
+    has_dsp3 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x03) {
+    has_dsp4 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0x25) {
+    has_obc1 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size >= 10) {
+    has_st010 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf6 && rom_size < 10) {
+    has_st011 = true;
+  }
+
+  if(mapperid == 0x30 && rom_type == 0xf5) {
+    has_st018 = true;
+  }
+}
+
+unsigned snes_information::find_header(const uint8_t *data, unsigned size) {
+  unsigned score_lo = score_header(data, size, 0x007fc0);
+  unsigned score_hi = score_header(data, size, 0x00ffc0);
+  unsigned score_ex = score_header(data, size, 0x40ffc0);
+  if(score_ex) score_ex += 4;  //favor ExHiROM on images > 32mbits
+
+  if(score_lo >= score_hi && score_lo >= score_ex) {
+    return 0x007fc0;
+  } else if(score_hi >= score_ex) {
+    return 0x00ffc0;
+  } else {
+    return 0x40ffc0;
+  }
+}
+
+unsigned snes_information::score_header(const uint8_t *data, unsigned size, unsigned addr) {
+  if(size < addr + 64) return 0;  //image too small to contain header at this location?
+  int score = 0;
+
+  uint16_t resetvector = data[addr + ResetVector] | (data[addr + ResetVector + 1] << 8);
+  uint16_t checksum    = data[addr + Checksum   ] | (data[addr + Checksum    + 1] << 8);
+  uint16_t complement  = data[addr + Complement ] | (data[addr + Complement  + 1] << 8);
+
+  uint8_t resetop = data[(addr & ~0x7fff) | (resetvector & 0x7fff)];  //first opcode executed upon reset
+  uint8_t mapper  = data[addr + Mapper] & ~0x10;                      //mask off irrelevent FastROM-capable bit
+
+  //$00:[000-7fff] contains uninitialized RAM and MMIO.
+  //reset vector must point to ROM at $00:[8000-ffff] to be considered valid.
+  if(resetvector < 0x8000) return 0;
+
+  //some images duplicate the header in multiple locations, and others have completely
+  //invalid header information that cannot be relied upon.
+  //below code will analyze the first opcode executed at the specified reset vector to
+  //determine the probability that this is the correct header.
+
+  //most likely opcodes
+  if(resetop == 0x78  //sei
+  || resetop == 0x18  //clc (clc; xce)
+  || resetop == 0x38  //sec (sec; xce)
+  || resetop == 0x9c  //stz $nnnn (stz $4200)
+  || resetop == 0x4c  //jmp $nnnn
+  || resetop == 0x5c  //jml $nnnnnn
+  ) score += 8;
+
+  //plausible opcodes
+  if(resetop == 0xc2  //rep #$nn
+  || resetop == 0xe2  //sep #$nn
+  || resetop == 0xad  //lda $nnnn
+  || resetop == 0xae  //ldx $nnnn
+  || resetop == 0xac  //ldy $nnnn
+  || resetop == 0xaf  //lda $nnnnnn
+  || resetop == 0xa9  //lda #$nn
+  || resetop == 0xa2  //ldx #$nn
+  || resetop == 0xa0  //ldy #$nn
+  || resetop == 0x20  //jsr $nnnn
+  || resetop == 0x22  //jsl $nnnnnn
+  ) score += 4;
+
+  //implausible opcodes
+  if(resetop == 0x40  //rti
+  || resetop == 0x60  //rts
+  || resetop == 0x6b  //rtl
+  || resetop == 0xcd  //cmp $nnnn
+  || resetop == 0xec  //cpx $nnnn
+  || resetop == 0xcc  //cpy $nnnn
+  ) score -= 4;
+
+  //least likely opcodes
+  if(resetop == 0x00  //brk #$nn
+  || resetop == 0x02  //cop #$nn
+  || resetop == 0xdb  //stp
+  || resetop == 0x42  //wdm
+  || resetop == 0xff  //sbc $nnnnnn,x
+  ) score -= 8;
+
+  //at times, both the header and reset vector's first opcode will match ...
+  //fallback and rely on info validity in these cases to determine more likely header.
+
+  //a valid checksum is the biggest indicator of a valid header.
+  if((checksum + complement) == 0xffff && (checksum != 0) && (complement != 0)) score += 4;
+
+  if(addr == 0x007fc0 && mapper == 0x20) score += 2;  //0x20 is usually LoROM
+  if(addr == 0x00ffc0 && mapper == 0x21) score += 2;  //0x21 is usually HiROM
+  if(addr == 0x007fc0 && mapper == 0x22) score += 2;  //0x22 is usually ExLoROM
+  if(addr == 0x40ffc0 && mapper == 0x25) score += 2;  //0x25 is usually ExHiROM
+
+  if(data[addr + Company] == 0x33) score += 2;        //0x33 indicates extended header
+  if(data[addr + RomType] < 0x08) score++;
+  if(data[addr + RomSize] < 0x10) score++;
+  if(data[addr + RamSize] < 0x08) score++;
+  if(data[addr + CartRegion] < 14) score++;
+
+  if(score < 0) score = 0;
+  return score;
+}
+
+unsigned snes_information::gameboy_ram_size(const uint8_t *data, unsigned size) {
+  if(size < 512) return 0;
+  switch(data[0x0149]) {
+    case 0x00: return   0 * 1024;
+    case 0x01: return   8 * 1024;
+    case 0x02: return   8 * 1024;
+    case 0x03: return  32 * 1024;
+    case 0x04: return 128 * 1024;
+    case 0x05: return 128 * 1024;
+    default:   return 128 * 1024;
+  }
+}
+
+bool snes_information::gameboy_has_rtc(const uint8_t *data, unsigned size) {
+  if(size < 512) return false;
+  if(data[0x0147] == 0x0f ||data[0x0147] == 0x10) return true;
+  return false;
+}
+
+}
+
+#endif

snesfilter/nall/static.hpp

@@ -0,0 +1,20 @@
+#ifndef NALL_STATIC_HPP
+#define NALL_STATIC_HPP
+
+namespace nall {
+  template<bool C, typename T, typename F> struct static_if { typedef T type; };
+  template<typename T, typename F> struct static_if<false, T, F> { typedef F type; };
+  template<typename C, typename T, typename F> struct mp_static_if { typedef typename static_if<C::type, T, F>::type type; };
+
+  template<bool A, bool B> struct static_and { enum { value = false }; };
+  template<> struct static_and<true, true> { enum { value = true }; };
+  template<typename A, typename B> struct mp_static_and { enum { value = static_and<A::value, B::value>::value }; };
+
+  template<bool A, bool B> struct static_or { enum { value = false }; };
+  template<> struct static_or<false, true> { enum { value = true }; };
+  template<> struct static_or<true, false> { enum { value = true }; };
+  template<> struct static_or<true, true> { enum { value = true }; };
+  template<typename A, typename B> struct mp_static_or { enum { value = static_or<A::value, B::value>::value }; };
+}
+
+#endif

snesfilter/nall/stdint.hpp

@@ -30,15 +30,15 @@
 #endif
 
 namespace nall {
-  static static_assert<sizeof(int8_t)   == 1> int8_t_assert;
-  static static_assert<sizeof(int16_t)  == 2> int16_t_assert;
-  static static_assert<sizeof(int32_t)  == 4> int32_t_assert;
-  static static_assert<sizeof(int64_t)  == 8> int64_t_assert;
+  static_assert(sizeof(int8_t)   == 1, "int8_t is not of the correct size" );
+  static_assert(sizeof(int16_t)  == 2, "int16_t is not of the correct size");
+  static_assert(sizeof(int32_t)  == 4, "int32_t is not of the correct size");
+  static_assert(sizeof(int64_t)  == 8, "int64_t is not of the correct size");
 
-  static static_assert<sizeof(uint8_t)  == 1> uint8_t_assert;
-  static static_assert<sizeof(uint16_t) == 2> uint16_t_assert;
-  static static_assert<sizeof(uint32_t) == 4> uint32_t_assert;
-  static static_assert<sizeof(uint64_t) == 8> uint64_t_assert;
+  static_assert(sizeof(uint8_t)  == 1, "int8_t is not of the correct size" );
+  static_assert(sizeof(uint16_t) == 2, "int16_t is not of the correct size");
+  static_assert(sizeof(uint32_t) == 4, "int32_t is not of the correct size");
+  static_assert(sizeof(uint64_t) == 8, "int64_t is not of the correct size");
 }
 
 #endif

snesfilter/nall/string.hpp

@@ -0,0 +1,29 @@
+#ifndef NALL_STRING_HPP
+#define NALL_STRING_HPP
+
+#include <initializer_list>
+#include <nall/utility.hpp>
+
+#include <nall/string/base.hpp>
+#include <nall/string/core.hpp>
+#include <nall/string/cast.hpp>
+#include <nall/string/compare.hpp>
+#include <nall/string/convert.hpp>
+#include <nall/string/filename.hpp>
+#include <nall/string/match.hpp>
+#include <nall/string/math.hpp>
+#include <nall/string/strl.hpp>
+#include <nall/string/strpos.hpp>
+#include <nall/string/trim.hpp>
+#include <nall/string/replace.hpp>
+#include <nall/string/split.hpp>
+#include <nall/string/utility.hpp>
+#include <nall/string/variadic.hpp>
+#include <nall/string/xml.hpp>
+
+namespace nall {
+  template<> struct has_length<string> { enum { value = true }; };
+  template<> struct has_size<lstring> { enum { value = true }; };
+}
+
+#endif

snesfilter/nall/string/base.hpp

@@ -0,0 +1,136 @@
+#ifndef NALL_STRING_BASE_HPP
+#define NALL_STRING_BASE_HPP
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <nall/concept.hpp>
+#include <nall/stdint.hpp>
+#include <nall/utf8.hpp>
+#include <nall/vector.hpp>
+
+namespace nall {
+  class string;
+  template<typename T> inline string to_string(T);
+
+  class string {
+  public:
+    inline void reserve(unsigned);
+    inline unsigned length() const;
+
+    inline string& assign(const char*);
+    inline string& append(const char*);
+    template<typename T> inline string& operator= (T value);
+    template<typename T> inline string& operator<<(T value);
+
+    inline operator const char*() const;
+    inline char* operator()();
+    inline char& operator[](int);
+
+    inline bool operator==(const char*) const;
+    inline bool operator!=(const char*) const;
+    inline bool operator< (const char*) const;
+    inline bool operator<=(const char*) const;
+    inline bool operator> (const char*) const;
+    inline bool operator>=(const char*) const;
+
+    inline string& operator=(const string&);
+    inline string& operator=(string&&);
+
+    inline string();
+    inline string(const char*);
+    inline string(const string&);
+    inline string(string&&);
+    inline ~string();
+
+    inline bool readfile(const char*);
+    inline string& replace (const char*, const char*);
+    inline string& qreplace(const char*, const char*);
+
+  protected:
+    char *data;
+    unsigned size;
+
+  #if defined(QSTRING_H)
+  public:
+    inline operator QString() const;
+  #endif
+  };
+
+  class lstring : public linear_vector<string> {
+  public:
+    template<typename T> inline lstring& operator<<(T value);
+
+    inline int find(const char*);
+    inline void split (const char*, const char*, unsigned = 0);
+    inline void qsplit(const char*, const char*, unsigned = 0);
+
+    lstring();
+    lstring(std::initializer_list<string>);
+  };
+
+  //compare.hpp
+  inline char chrlower(char c);
+  inline char chrupper(char c);
+  inline int stricmp(const char *dest, const char *src);
+  inline bool strbegin (const char *str, const char *key);
+  inline bool stribegin(const char *str, const char *key);
+  inline bool strend (const char *str, const char *key);
+  inline bool striend(const char *str, const char *key);
+
+  //convert.hpp
+  inline char* strlower(char *str);
+  inline char* strupper(char *str);
+  inline char* strtr(char *dest, const char *before, const char *after);
+  inline uintmax_t strhex     (const char *str);
+  inline intmax_t  strsigned  (const char *str);
+  inline uintmax_t strunsigned(const char *str);
+  inline uintmax_t strbin     (const char *str);
+  inline double    strdouble  (const char *str);
+
+  //match.hpp
+  inline bool match(const char *pattern, const char *str);
+
+  //math.hpp
+  inline bool strint (const char *str, int &result);
+  inline bool strmath(const char *str, int &result);
+
+  //strl.hpp
+  inline unsigned strlcpy(char *dest, const char *src, unsigned length);
+  inline unsigned strlcat(char *dest, const char *src, unsigned length);
+
+  //trim.hpp
+  inline char* ltrim(char *str, const char *key = " ");
+  inline char* rtrim(char *str, const char *key = " ");
+  inline char* trim (char *str, const char *key = " ");
+  inline char* ltrim_once(char *str, const char *key = " ");
+  inline char* rtrim_once(char *str, const char *key = " ");
+  inline char* trim_once (char *str, const char *key = " ");
+
+  //utility.hpp
+  inline unsigned strlcpy(string &dest, const char *src, unsigned length);
+  inline unsigned strlcat(string &dest, const char *src, unsigned length);
+  inline string substr(const char *src, unsigned start = 0, unsigned length = 0);
+  inline string& strlower(string &str);
+  inline string& strupper(string &str);
+  inline string& strtr(string &dest, const char *before, const char *after);
+  inline string& ltrim(string &str, const char *key = " ");
+  inline string& rtrim(string &str, const char *key = " ");
+  inline string& trim (string &str, const char *key = " ");
+  inline string& ltrim_once(string &str, const char *key = " ");
+  inline string& rtrim_once(string &str, const char *key = " ");
+  inline string& trim_once (string &str, const char *key = " ");
+  template<unsigned length = 0, char padding = '0'> inline string strhex(uintmax_t value);
+  template<unsigned length = 0, char padding = '0'> inline string strsigned(intmax_t value);
+  template<unsigned length = 0, char padding = '0'> inline string strunsigned(uintmax_t value);
+  template<unsigned length = 0, char padding = '0'> inline string strbin(uintmax_t value);
+  inline unsigned strdouble(char *str, double value);
+  inline string strdouble(double value);
+
+  //variadic.hpp
+  template<typename... Args> inline string sprint(Args... args);
+  template<typename... Args> inline void print(Args... args);
+};
+
+#endif

snesfilter/nall/string/cast.hpp

@@ -0,0 +1,32 @@
+#ifndef NALL_STRING_CAST_HPP
+#define NALL_STRING_CAST_HPP
+
+namespace nall {
+
+//this is needed, as C++0x does not support explicit template specialization inside classes
+template<> inline string to_string<bool>         (bool v)          { return v ? "true" : "false"; }
+template<> inline string to_string<signed int>   (signed int v)    { return strsigned(v); }
+template<> inline string to_string<unsigned int> (unsigned int v)  { return strunsigned(v); }
+template<> inline string to_string<double>       (double v)        { return strdouble(v); }
+template<> inline string to_string<char*>        (char *v)         { return v; }
+template<> inline string to_string<const char*>  (const char *v)   { return v; }
+template<> inline string to_string<string>       (string v)        { return v; }
+template<> inline string to_string<const string&>(const string &v) { return v; }
+
+template<typename T> string& string::operator= (T value) { return assign(to_string<T>(value)); }
+template<typename T> string& string::operator<<(T value) { return append(to_string<T>(value)); }
+
+template<typename T> lstring& lstring::operator<<(T value) {
+  operator[](size()).assign(to_string<T>(value));
+  return *this;
+}
+
+#if defined(QSTRING_H)
+template<> inline string to_string<QString>(QString v) { return v.toUtf8().constData(); }
+template<> inline string to_string<const QString&>(const QString &v) { return v.toUtf8().constData(); }
+string::operator QString() const { return QString::fromUtf8(*this); }
+#endif
+
+}
+
+#endif

snesfilter/nall/string/compare.hpp

@@ -1,4 +1,7 @@
-#ifdef NALL_STRING_CPP
+#ifndef NALL_STRING_COMPARE_HPP
+#define NALL_STRING_COMPARE_HPP
+
+namespace nall {
 
 char chrlower(char c) {
   return (c >= 'A' && c <= 'Z') ? c + ('a' - 'A') : c;
@@ -18,38 +21,6 @@ int stricmp(const char *dest, const char *src) {
   return (int)chrlower(*dest) - (int)chrlower(*src);
 }
 
-int strpos(const char *str, const char *key) {
-  int ssl = strlen(str), ksl = strlen(key);
-
-  if(ksl > ssl) return -1;
-  for(int i = 0; i <= ssl - ksl; i++) {
-    if(!memcmp(str + i, key, ksl)) {
-      return i;
-    }
-  }
-  return -1;
-}
-
-int qstrpos(const char *str, const char *key) {
-  int ssl = strlen(str), ksl = strlen(key);
-
-  if(ksl > ssl) return -1;
-  for(int i = 0; i <= ssl - ksl;) {
-  uint8_t x = str[i];
-    if(x == '\"' || x == '\'') {
-    uint8_t z = i++;
-      while(str[i] != x && i < ssl) i++;
-      if(i >= ssl) i = z;
-    }
-    if(!memcmp(str + i, key, ksl)) {
-      return i;
-    } else {
-      i++;
-    }
-  }
-  return -1;
-}
-
 bool strbegin(const char *str, const char *key) {
   int i, ssl = strlen(str), ksl = strlen(key);
 
@@ -96,4 +67,6 @@ bool striend(const char *str, const char *key) {
   return true;
 }
 
+}
+
 #endif

snesfilter/nall/string/convert.hpp

@@ -0,0 +1,153 @@
+#ifndef NALL_STRING_CONVERT_HPP
+#define NALL_STRING_CONVERT_HPP
+
+namespace nall {
+
+char* strlower(char *str) {
+  if(!str) return 0;
+  int i = 0;
+  while(str[i]) {
+    str[i] = chrlower(str[i]);
+    i++;
+  }
+  return str;
+}
+
+char* strupper(char *str) {
+  if(!str) return 0;
+  int i = 0;
+  while(str[i]) {
+    str[i] = chrupper(str[i]);
+    i++;
+  }
+  return str;
+}
+
+char* strtr(char *dest, const char *before, const char *after) {
+  if(!dest || !before || !after) return dest;
+  int sl = strlen(dest), bsl = strlen(before), asl = strlen(after);
+
+  if(bsl != asl || bsl == 0) return dest;  //patterns must be the same length for 1:1 replace
+  for(unsigned i = 0; i < sl; i++) {
+    for(unsigned l = 0; l < bsl; l++) {
+      if(dest[i] == before[l]) {
+        dest[i] = after[l];
+        break;
+      }
+    }
+  }
+
+  return dest;
+}
+
+uintmax_t strhex(const char *str) {
+  if(!str) return 0;
+  uintmax_t result = 0;
+
+  //skip hex identifiers 0x and $, if present
+  if(*str == '0' && (*(str + 1) == 'X' || *(str + 1) == 'x')) str += 2;
+  else if(*str == '$') str++;
+
+  while(*str) {
+    uint8_t x = *str++;
+    if(x >= '0' && x <= '9') x -= '0';
+    else if(x >= 'A' && x <= 'F') x -= 'A' - 10;
+    else if(x >= 'a' && x <= 'f') x -= 'a' - 10;
+    else break;  //stop at first invalid character
+    result = result * 16 + x;
+  }
+
+  return result;
+}
+
+intmax_t strsigned(const char *str) {
+  if(!str) return 0;
+  intmax_t result = 0;
+  bool negate = false;
+
+  //check for negation
+  if(*str == '-') {
+    negate = true;
+    str++;
+  }
+
+  while(*str) {
+    uint8_t x = *str++;
+    if(x >= '0' && x <= '9') x -= '0';
+    else break;  //stop at first invalid character
+    result = result * 10 + x;
+  }
+
+  return !negate ? result : -result;
+}
+
+uintmax_t strunsigned(const char *str) {
+  if(!str) return 0;
+  uintmax_t result = 0;
+
+  while(*str) {
+    uint8_t x = *str++;
+    if(x >= '0' && x <= '9') x -= '0';
+    else break;  //stop at first invalid character
+    result = result * 10 + x;
+  }
+
+  return result;
+}
+
+uintmax_t strbin(const char *str) {
+  if(!str) return 0;
+  uintmax_t result = 0;
+
+  //skip bin identifiers 0b and %, if present
+  if(*str == '0' && (*(str + 1) == 'B' || *(str + 1) == 'b')) str += 2;
+  else if(*str == '%') str++;
+
+  while(*str) {
+    uint8_t x = *str++;
+    if(x == '0' || x == '1') x -= '0';
+    else break;  //stop at first invalid character
+    result = result * 2 + x;
+  }
+
+  return result;
+}
+
+double strdouble(const char *str) {
+  if(!str) return 0.0;
+  bool negate = false;
+
+  //check for negation
+  if(*str == '-') {
+    negate = true;
+    str++;
+  }
+
+  intmax_t result_integral = 0;
+  while(*str) {
+    uint8_t x = *str++;
+    if(x >= '0' && x <= '9') x -= '0';
+    else if(x == '.' || x == ',') break;  //break loop and read fractional part
+    else return (double)result_integral;  //invalid value, assume no fractional part
+    result_integral = result_integral * 10 + x;
+  }
+
+  intmax_t result_fractional = 0;
+  while(*str) {
+    uint8_t x = *str++;
+    if(x >= '0' && x <= '9') x -= '0';
+    else break;  //stop at first invalid character
+    result_fractional = result_fractional * 10 + x;
+  }
+
+  //calculate fractional portion
+  double result = (double)result_fractional;
+  while((uintmax_t)result > 0) result /= 10.0;
+  result += (double)result_integral;
+
+  return !negate ? result : -result;
+}
+
+}
+
+#endif

snesfilter/nall/string/core.hpp

@@ -0,0 +1,133 @@
+#ifndef NALL_STRING_CORE_HPP
+#define NALL_STRING_CORE_HPP
+
+namespace nall {
+
+void string::reserve(unsigned size_) {
+  if(size_ > size) {
+    size = size_;
+    data = (char*)realloc(data, size + 1);
+    data[size] = 0;
+  }
+}
+
+unsigned string::length() const {
+  return strlen(data);
+}
+
+string& string::assign(const char *s) {
+  unsigned length = strlen(s);
+  reserve(length);
+  strcpy(data, s);
+  return *this;
+}
+
+string& string::append(const char *s) {
+  unsigned length = strlen(data) + strlen(s);
+  reserve(length);
+  strcat(data, s);
+  return *this;
+}
+
+string::operator const char*() const {
+  return data;
+}
+
+char* string::operator()() {
+  return data;
+}
+
+char& string::operator[](int index) {
+  reserve(index);
+  return data[index];
+}
+
+bool string::operator==(const char *str) const { return strcmp(data, str) == 0; }
+bool string::operator!=(const char *str) const { return strcmp(data, str) != 0; }
+bool string::operator< (const char *str) const { return strcmp(data, str)  < 0; }
+bool string::operator<=(const char *str) const { return strcmp(data, str) <= 0; }
+bool string::operator> (const char *str) const { return strcmp(data, str)  > 0; }
+bool string::operator>=(const char *str) const { return strcmp(data, str) >= 0; }
+
+string& string::operator=(const string &value) {
+  assign(value);
+  return *this;
+}
+
+string& string::operator=(string &&source) {
+  if(data) free(data);
+  size = source.size;
+  data = source.data;
+  source.data = 0;
+  source.size = 0;
+  return *this;
+}
+
+string::string() {
+  size = 64;
+  data = (char*)malloc(size + 1);
+  *data = 0;
+}
+
+string::string(const char *value) {
+  size = strlen(value);
+  data = strdup(value);
+}
+
+string::string(const string &value) {
+  size = strlen(value);
+  data = strdup(value);
+}
+
+string::string(string &&source) {
+  size = source.size;
+  data = source.data;
+  source.data = 0;
+}
+
+string::~string() {
+  free(data);
+}
+
+bool string::readfile(const char *filename) {
+  assign("");
+
+  #if !defined(_WIN32)
+  FILE *fp = fopen(filename, "rb");
+  #else
+  FILE *fp = _wfopen(utf16_t(filename), L"rb");
+  #endif
+  if(!fp) return false;
+
+  fseek(fp, 0, SEEK_END);
+  unsigned size = ftell(fp);
+  rewind(fp);
+  char *fdata = new char[size + 1];
+  unsigned unused = fread(fdata, 1, size, fp);
+  fclose(fp);
+  fdata[size] = 0;
+  assign(fdata);
+  delete[] fdata;
+
+  return true;
+}
+
+int lstring::find(const char *key) {
+  for(unsigned i = 0; i < size(); i++) {
+    if(operator[](i) == key) return i;
+  }
+  return -1;
+}
+
+inline lstring::lstring() {
+}
+
+inline lstring::lstring(std::initializer_list<string> list) {
+  for(const string *s = list.begin(); s != list.end(); ++s) {
+    operator<<(*s);
+  }
+}
+
+}
+
+#endif

snesfilter/nall/string/filename.hpp

@@ -0,0 +1,61 @@
+#ifndef NALL_FILENAME_HPP
+#define NALL_FILENAME_HPP
+
+namespace nall {
+
+// "foo/bar.c" -> "foo/", "bar.c" -> "./"
+inline string dir(char const *name) {
+  string result = name;
+  for(signed i = strlen(result); i >= 0; i--) {
+    if(result[i] == '/' || result[i] == '\\') {
+      result[i + 1] = 0;
+      break;
+    }
+    if(i == 0) result = "./";
+  }
+  return result;
+}
+
+// "foo/bar.c" -> "bar.c"
+inline string notdir(char const *name) {
+  for(signed i = strlen(name); i >= 0; i--) {
+    if(name[i] == '/' || name[i] == '\\') {
+      name += i + 1;
+      break;
+    }
+  }
+  string result = name;
+  return result;
+}
+
+// "foo/bar.c" -> "foo/bar"
+inline string basename(char const *name) {
+  string result = name;
+  for(signed i = strlen(result); i >= 0; i--) {
+    if(result[i] == '/' || result[i] == '\\') {
+      //file has no extension
+      break;
+    }
+    if(result[i] == '.') {
+      result[i] = 0;
+      break;
+    }
+  }
+  return result;
+}
+
+// "foo/bar.c" -> "c"
+inline string extension(char const *name) {
+  for(signed i = strlen(name); i >= 0; i--) {
+    if(name[i] == '.') {
+      name += i + 1;
+      break;
+    }
+  }
+  string result = name;
+  return result;
+}
+
+}
+
+#endif

snesfilter/nall/string/match.hpp

@@ -1,4 +1,7 @@
-#ifdef NALL_STRING_CPP
+#ifndef NALL_STRING_MATCH_HPP
+#define NALL_STRING_MATCH_HPP
+
+namespace nall {
 
 bool match(const char *p, const char *s) {
   const char *p_ = 0, *s_ = 0;
@@ -68,4 +71,6 @@ bool match(const char *p, const char *s) {
   }
 }
 
+}
+
 #endif

snesfilter/nall/string/math.hpp

@@ -1,4 +1,7 @@
-#ifdef NALL_STRING_CPP
+#ifndef NALL_STRING_MATH_HPP
+#define NALL_STRING_MATH_HPP
+
+namespace nall {
 
 static int eval_integer(const char *&s) {
   if(!*s) throw "unrecognized_integer";
@@ -156,4 +159,6 @@ bool strmath(const char *s, int &result) {
   }
 }
 
+}
+
 #endif

snesfilter/nall/string/replace.hpp

@@ -0,0 +1,103 @@
+#ifndef NALL_STRING_REPLACE_HPP
+#define NALL_STRING_REPLACE_HPP
+
+namespace nall {
+
+string& string::replace(const char *key, const char *token) {
+  int i, z, ksl = strlen(key), tsl = strlen(token), ssl = length();
+  unsigned int replace_count = 0, size = ssl;
+  char *buffer;
+
+  if(ksl <= ssl) {
+    if(tsl > ksl) {                      //the new string may be longer than the old string...
+      for(i = 0; i <= ssl - ksl;) {      //so let's find out how big of a string we'll need...
+        if(!memcmp(data + i, key, ksl)) {
+          replace_count++;
+          i += ksl;
+        } else i++;
+      }
+      size = ssl + ((tsl - ksl) * replace_count);
+      reserve(size);
+    }
+
+    buffer = new char[size + 1];
+    for(i = z = 0; i < ssl;) {
+      if(i <= ssl - ksl) {
+        if(!memcmp(data + i, key, ksl)) {
+          memcpy(buffer + z, token, tsl);
+          z += tsl;
+          i += ksl;
+        } else buffer[z++] = data[i++];
+      } else buffer[z++] = data[i++];
+    }
+    buffer[z] = 0;
+
+    assign(buffer);
+    delete[] buffer;
+  }
+
+  return *this;
+}
+
+string& string::qreplace(const char *key, const char *token) {
+  int i, l, z, ksl = strlen(key), tsl = strlen(token), ssl = length();
+  unsigned int replace_count = 0, size = ssl;
+  uint8_t x;
+  char *buffer;
+
+  if(ksl <= ssl) {
+    if(tsl > ksl) {
+      for(i = 0; i <= ssl - ksl;) {
+        x = data[i];
+        if(x == '\"' || x == '\'') {
+          l = i;
+          i++;
+          while(data[i++] != x) {
+            if(i == ssl) {
+              i = l;
+              break;
+            }
+          }
+        }
+        if(!memcmp(data + i, key, ksl)) {
+          replace_count++;
+          i += ksl;
+        } else i++;
+      }
+      size = ssl + ((tsl - ksl) * replace_count);
+      reserve(size);
+    }
+
+    buffer = new char[size + 1];
+    for(i = z = 0; i < ssl;) {
+      x = data[i];
+      if(x == '\"' || x == '\'') {
+        l = i++;
+        while(data[i] != x && i < ssl)i++;
+        if(i >= ssl)i = l;
+        else {
+          memcpy(buffer + z, data + l, i - l);
+          z += i - l;
+        }
+      }
+      if(i <= ssl - ksl) {
+        if(!memcmp(data + i, key, ksl)) {
+          memcpy(buffer + z, token, tsl);
+          z += tsl;
+          i += ksl;
+          replace_count++;
+        } else buffer[z++] = data[i++];
+      } else buffer[z++] = data[i++];
+    }
+    buffer[z] = 0;
+
+    assign(buffer);
+    delete[] buffer;
+  }
+
+  return *this;
+}
+
+};
+
+#endif

snesfilter/nall/string/split.hpp

@@ -0,0 +1,56 @@
+#ifndef NALL_STRING_SPLIT_HPP
+#define NALL_STRING_SPLIT_HPP
+
+namespace nall {
+
+void lstring::split(const char *key, const char *src, unsigned limit) {
+  reset();
+
+  int ssl = strlen(src), ksl = strlen(key);
+  int lp = 0, split_count = 0;
+
+  for(int i = 0; i <= ssl - ksl;) {
+    if(!memcmp(src + i, key, ksl)) {
+      strlcpy(operator[](split_count++), src + lp, i - lp + 1);
+      i += ksl;
+      lp = i;
+      if(!--limit) break;
+    } else i++;
+  }
+
+  operator[](split_count++) = src + lp;
+}
+
+void lstring::qsplit(const char *key, const char *src, unsigned limit) {
+  reset();
+
+  int ssl = strlen(src), ksl = strlen(key);
+  int lp = 0, split_count = 0;
+
+  for(int i = 0; i <= ssl - ksl;) {
+    uint8_t x = src[i];
+
+    if(x == '\"' || x == '\'') {
+      int z = i++;                        //skip opening quote
+      while(i < ssl && src[i] != x) i++;
+      if(i >= ssl) i = z;                 //failed match, rewind i
+      else {
+        i++;                              //skip closing quote
+        continue;                         //restart in case next char is also a quote
+      }
+    }
+
+    if(!memcmp(src + i, key, ksl)) {
+      strlcpy(operator[](split_count++), src + lp, i - lp + 1);
+      i += ksl;
+      lp = i;
+      if(!--limit) break;
+    } else i++;
+  }
+
+  operator[](split_count++) = src + lp;
+}
+
+};
+
+#endif

snesfilter/nall/string/strl.hpp

@@ -1,12 +1,15 @@
-#ifdef NALL_STRING_CPP
+#ifndef NALL_STRING_STRL_HPP
+#define NALL_STRING_STRL_HPP
+
+namespace nall {
 
 //strlcpy, strlcat based on OpenBSD implementation by Todd C. Miller
 
 //return = strlen(src)
-size_t strlcpy(char *dest, const char *src, size_t length) {
+unsigned strlcpy(char *dest, const char *src, unsigned length) {
   char *d = dest;
   const char *s = src;
-  size_t n = length;
+  unsigned n = length;
 
   if(n) {
     while(--n && (*d++ = *s++)); //copy as many bytes as possible, or until null terminator reached
@@ -21,13 +24,13 @@ size_t strlcpy(char *dest, const char *src, size_t length) {
 }
 
 //return = strlen(src) + min(length, strlen(dest))
-size_t strlcat(char *dest, const char *src, size_t length) {
+unsigned strlcat(char *dest, const char *src, unsigned length) {
   char *d = dest;
   const char *s = src;
-  size_t n = length;
+  unsigned n = length;
 
   while(n-- && *d) d++; //find end of dest
-  size_t dlength = d - dest;
+  unsigned dlength = d - dest;
   n = length - dlength; //subtract length of dest from maximum string length
 
   if(!n) return dlength + strlen(s);
@@ -44,4 +47,6 @@ size_t strlcat(char *dest, const char *src, size_t length) {
   return dlength + (s - src); //return length of resulting string, sans null terminator
 }
 
+}
+
 #endif

snesfilter/nall/string/strpos.hpp

@@ -0,0 +1,41 @@
+#ifndef NALL_STRING_STRPOS_HPP
+#define NALL_STRING_STRPOS_HPP
+
+//usage example:
+//if(auto pos = strpos(str, key)) print(pos(), "\n");
+//prints position of key within str, only if it is found
+
+namespace nall {
+
+optional<unsigned> inline strpos(const char *str, const char *key) {
+  unsigned ssl = strlen(str), ksl = strlen(key);
+  if(ksl > ssl) return { false, 0 };
+
+  for(unsigned i = 0; i <= ssl - ksl; i++) {
+    if(!memcmp(str + i, key, ksl)) return { true, i };
+  }
+
+  return { false, 0 };
+}
+
+optional<unsigned> inline qstrpos(const char *str, const char *key) {
+  unsigned ssl = strlen(str), ksl = strlen(key);
+  if(ksl > ssl) return { false, 0 };
+
+  for(unsigned i = 0; i <= ssl - ksl;) {
+    uint8_t x = str[i];
+    if(x == '\"' || x == '\'') {
+      uint8_t z = i++;
+      while(str[i] != x && i < ssl) i++;
+      if(i >= ssl) i = z;
+    }
+    if(!memcmp(str + i, key, ksl)) return { true, i };
+    i++;
+  }
+
+  return { false, 0 };
+}
+
+}
+
+#endif

snesfilter/nall/string/trim.hpp

@@ -1,8 +1,18 @@
-#ifdef NALL_STRING_CPP
+#ifndef NALL_STRING_TRIM_HPP
+#define NALL_STRING_TRIM_HPP
+
+namespace nall {
 
 char* ltrim(char *str, const char *key) {
   if(!key || !*key) return str;
-  while(strbegin(str, key)) strcpy(str, str + strlen(key));
+  while(strbegin(str, key)) {
+    char *dest = str, *src = str + strlen(key);
+    while(true) {
+      *dest = *src++;
+      if(!*dest) break;
+      dest++;
+    }
+  }
   return str;
 }
 
@@ -18,7 +28,14 @@ char* trim(char *str, const char *key) {
 
 char* ltrim_once(char *str, const char *key) {
   if(!key || !*key) return str;
-  if(strbegin(str, key)) strcpy(str, str + strlen(key));
+  if(strbegin(str, key)) {
+    char *dest = str, *src = str + strlen(key);
+    while(true) {
+      *dest = *src++;
+      if(!*dest) break;
+      dest++;
+    }
+  }
   return str;
 }
 
@@ -32,4 +49,6 @@ char* trim_once(char *str, const char *key) {
   return ltrim_once(rtrim_once(str, key), key);
 }
 
+}
+
 #endif

snesfilter/nall/string/utility.hpp

@@ -0,0 +1,169 @@
+#ifndef NALL_STRING_UTILITY_HPP
+#define NALL_STRING_UTILITY_HPP
+
+namespace nall {
+
+unsigned strlcpy(string &dest, const char *src, unsigned length) {
+  dest.reserve(length);
+  return strlcpy(dest(), src, length);
+}
+
+unsigned strlcat(string &dest, const char *src, unsigned length) {
+  dest.reserve(length);
+  return strlcat(dest(), src, length);
+}
+
+string substr(const char *src, unsigned start, unsigned length) {
+  string dest;
+  if(length == 0) {
+    //copy entire string
+    dest = src + start;
+  } else {
+    //copy partial string
+    strlcpy(dest, src + start, length + 1);
+  }
+  return dest;
+}
+
+/* very simplistic wrappers to return string& instead of char* type */
+
+string& strlower(string &str) { strlower(str()); return str; }
+string& strupper(string &str) { strupper(str()); return str; }
+string& strtr(string &dest, const char *before, const char *after) { strtr(dest(), before, after); return dest; }
+string& ltrim(string &str, const char *key) { ltrim(str(), key); return str; }
+string& rtrim(string &str, const char *key) { rtrim(str(), key); return str; }
+string& trim (string &str, const char *key) { trim (str(), key); return str; }
+string& ltrim_once(string &str, const char *key) { ltrim_once(str(), key); return str; }
+string& rtrim_once(string &str, const char *key) { rtrim_once(str(), key); return str; }
+string& trim_once (string &str, const char *key) { trim_once (str(), key); return str; }
+
+/* arithmetic <> string */
+
+template<unsigned length, char padding> string strhex(uintmax_t value) {
+  string output;
+  unsigned offset = 0;
+
+  //render string backwards, as we do not know its length yet
+  do {
+    unsigned n = value & 15;
+    output[offset++] = n < 10 ? '0' + n : 'a' + n - 10;
+    value >>= 4;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  //reverse the string in-place
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
+}
+
+template<unsigned length, char padding> string strsigned(intmax_t value) {
+  string output;
+  unsigned offset = 0;
+
+  bool negative = value < 0;
+  if(negative) value = abs(value);
+
+  do {
+    unsigned n = value % 10;
+    output[offset++] = '0' + n;
+    value /= 10;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  if(negative) output[offset++] = '-';
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
+}
+
+template<unsigned length, char padding> string strunsigned(uintmax_t value) {
+  string output;
+  unsigned offset = 0;
+
+  do {
+    unsigned n = value % 10;
+    output[offset++] = '0' + n;
+    value /= 10;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
+}
+
+template<unsigned length, char padding> string strbin(uintmax_t value) {
+  string output;
+  unsigned offset = 0;
+
+  do {
+    unsigned n = value & 1;
+    output[offset++] = '0' + n;
+    value >>= 1;
+  } while(value);
+
+  while(offset < length) output[offset++] = padding;
+  output[offset--] = 0;
+
+  for(unsigned i = 0; i < (offset + 1) >> 1; i++) {
+    char temp = output[i];
+    output[i] = output[offset - i];
+    output[offset - i] = temp;
+  }
+
+  return output;
+}
+
+//using sprintf is certainly not the most ideal method to convert
+//a double to a string ... but attempting to parse a double by
+//hand, digit-by-digit, results in subtle rounding errors.
+unsigned strdouble(char *str, double value) {
+  char buffer[256];
+  sprintf(buffer, "%f", value);
+
+  //remove excess 0's in fraction (2.500000 -> 2.5)
+  for(char *p = buffer; *p; p++) {
+    if(*p == '.') {
+      char *p = buffer + strlen(buffer) - 1;
+      while(*p == '0') {
+        if(*(p - 1) != '.') *p = 0;  //... but not for eg 1.0 -> 1.
+        p--;
+      }
+      break;
+    }
+  }
+
+  unsigned length = strlen(buffer);
+  if(str) strcpy(str, buffer);
+  return length + 1;
+}
+
+string strdouble(double value) {
+  string temp;
+  temp.reserve(strdouble(0, value));
+  strdouble(temp(), value);
+  return temp;
+}
+
+}
+
+#endif

snesfilter/nall/string/variadic.hpp

@@ -0,0 +1,27 @@
+#ifndef NALL_STRING_VARIADIC_HPP
+#define NALL_STRING_VARIADIC_HPP
+
+namespace nall {
+
+static void isprint(string &output) {
+}
+
+template<typename T, typename... Args>
+static void isprint(string &output, T value, Args... args) {
+  output << to_string<T>(value);
+  isprint(output, args...);
+}
+
+template<typename... Args> inline string sprint(Args... args) {
+  string output;
+  isprint(output, args...);
+  return output;
+}
+
+template<typename... Args> inline void print(Args... args) {
+  printf("%s", (const char*)sprint(args...));
+}
+
+}
+
+#endif

snesfilter/nall/string/xml.hpp

@@ -0,0 +1,265 @@
+#ifndef NALL_STRING_XML_HPP
+#define NALL_STRING_XML_HPP
+
+//XML subset parser
+//version 0.05
+
+namespace nall {
+
+struct xml_attribute {
+  string name;
+  string content;
+  virtual string parse() const;
+};
+
+struct xml_element : xml_attribute {
+  string parse() const;
+  linear_vector<xml_attribute> attribute;
+  linear_vector<xml_element> element;
+
+protected:
+  void parse_doctype(const char *&data);
+  bool parse_head(string data);
+  bool parse_body(const char *&data);
+  friend xml_element xml_parse(const char *data);
+};
+
+inline string xml_attribute::parse() const {
+  string data;
+  unsigned offset = 0;
+
+  const char *source = content;
+  while(*source) {
+    if(*source == '&') {
+      if(strbegin(source, "&lt;"))   { data[offset++] = '<';  source += 4; continue; }
+      if(strbegin(source, "&gt;"))   { data[offset++] = '>';  source += 4; continue; }
+      if(strbegin(source, "&amp;"))  { data[offset++] = '&';  source += 5; continue; }
+      if(strbegin(source, "&apos;")) { data[offset++] = '\''; source += 6; continue; }
+      if(strbegin(source, "&quot;")) { data[offset++] = '"';  source += 6; continue; }
+    }
+
+    //reject illegal characters
+    if(*source == '&') return "";
+    if(*source == '<') return "";
+    if(*source == '>') return "";
+
+    data[offset++] = *source++;
+  }
+
+  data[offset] = 0;
+  return data;
+}
+
+inline string xml_element::parse() const {
+  string data;
+  unsigned offset = 0;
+
+  const char *source = content;
+  while(*source) {
+    if(*source == '&') {
+      if(strbegin(source, "&lt;"))   { data[offset++] = '<';  source += 4; continue; }
+      if(strbegin(source, "&gt;"))   { data[offset++] = '>';  source += 4; continue; }
+      if(strbegin(source, "&amp;"))  { data[offset++] = '&';  source += 5; continue; }
+      if(strbegin(source, "&apos;")) { data[offset++] = '\''; source += 6; continue; }
+      if(strbegin(source, "&quot;")) { data[offset++] = '"';  source += 6; continue; }
+    }
+
+    if(strbegin(source, "<!--")) {
+      if(auto pos = strpos(source, "-->")) {
+        source += pos() + 3;
+        continue;
+      } else {
+        return "";
+      }
+    }
+
+    if(strbegin(source, "<![CDATA[")) {
+      if(auto pos = strpos(source, "]]>")) {
+        string cdata = substr(source, 9, pos() - 9);
+        data << cdata;
+        offset += strlen(cdata);
+
+        source += offset + 3;
+        continue;
+      } else {
+        return "";
+      }
+    }
+
+    //reject illegal characters
+    if(*source == '&') return "";
+    if(*source == '<') return "";
+    if(*source == '>') return "";
+
+    data[offset++] = *source++;
+  }
+
+  data[offset] = 0;
+  return data;
+}
+
+inline void xml_element::parse_doctype(const char *&data) {
+  name = "!DOCTYPE";
+  const char *content_begin = data;
+
+  signed counter = 0;
+  while(*data) {
+    char value = *data++;
+    if(value == '<') counter++;
+    if(value == '>') counter--;
+    if(counter < 0) {
+      content = substr(content_begin, 0, data - content_begin - 1);
+      return;
+    }
+  }
+  throw "...";
+}
+
+inline bool xml_element::parse_head(string data) {
+  data.qreplace("\t", " ");
+  data.qreplace("\r", " ");
+  data.qreplace("\n", " ");
+  while(qstrpos(data, "  ")) data.qreplace("  ", " ");
+  data.qreplace(" =", "=");
+  data.qreplace("= ", "=");
+  rtrim(data);
+
+  lstring part;
+  part.qsplit(" ", data);
+
+  name = part[0];
+  if(name == "") throw "...";
+
+  for(unsigned i = 1; i < part.size(); i++) {
+    lstring side;
+    side.qsplit("=", part[i]);
+    if(side.size() != 2) throw "...";
+
+    xml_attribute attr;
+    attr.name = side[0];
+    attr.content = side[1];
+    if(strbegin(attr.content, "\"") && strend(attr.content, "\"")) trim_once(attr.content, "\"");
+    else if(strbegin(attr.content, "'") && strend(attr.content, "'")) trim_once(attr.content, "'");
+    else throw "...";
+    attribute.append(attr);
+  }
+}
+
+inline bool xml_element::parse_body(const char *&data) {
+  while(true) {
+    if(!*data) return false;
+    if(*data++ != '<') continue;
+    if(*data == '/') return false;
+
+    if(strbegin(data, "!DOCTYPE") == true) {
+      parse_doctype(data);
+      return true;
+    }
+
+    if(strbegin(data, "!--")) {
+      if(auto offset = strpos(data, "-->")) {
+        data += offset() + 3;
+        continue;
+      } else {
+        throw "...";
+      }
+    }
+
+    if(strbegin(data, "![CDATA[")) {
+      if(auto offset = strpos(data, "]]>")) {
+        data += offset() + 3;
+        continue;
+      } else {
+        throw "...";
+      }
+    }
+
+    auto offset = strpos(data, ">");
+    if(!offset) throw "...";
+
+    string tag = substr(data, 0, offset());
+    data += offset() + 1;
+    const char *content_begin = data;
+
+    bool self_terminating = false;
+
+    if(strend(tag, "?") == true) {
+      self_terminating = true;
+      rtrim_once(tag, "?");
+    } else if(strend(tag, "/") == true) {
+      self_terminating = true;
+      rtrim_once(tag, "/");
+    }
+
+    parse_head(tag);
+    if(self_terminating) return true;
+
+    while(*data) {
+      unsigned index = element.size();
+      xml_element node;
+      if(node.parse_body(data) == false) {
+        if(*data == '/') {
+          signed length = data - content_begin - 1;
+          if(length > 0) content = substr(content_begin, 0, length);
+
+          data++;
+          auto offset = strpos(data, ">");
+          if(!offset) throw "...";
+
+          tag = substr(data, 0, offset());
+          data += offset() + 1;
+
+          tag.replace("\t", " ");
+          tag.replace("\r", " ");
+          tag.replace("\n", " ");
+          while(strpos(tag, "  ")) tag.replace("  ", " ");
+          rtrim(tag);
+
+          if(name != tag) throw "...";
+          return true;
+        }
+      } else {
+        element.append(node);
+      }
+    }
+  }
+}
+
+//ensure there is only one root element
+inline bool xml_validate(xml_element &document) {
+  unsigned root_counter = 0;
+
+  for(unsigned i = 0; i < document.element.size(); i++) {
+    string &name = document.element[i].name;
+    if(strbegin(name, "?")) continue;
+    if(strbegin(name, "!")) continue;
+    if(++root_counter > 1) return false;
+  }
+
+  return true;
+}
+
+inline xml_element xml_parse(const char *data) {
+  xml_element self;
+
+  try {
+    while(*data) {
+      xml_element node;
+      if(node.parse_body(data) == false) {
+        break;
+      } else {
+        self.element.append(node);
+      }
+    }
+
+    if(xml_validate(self) == false) throw "...";
+    return self;
+  } catch(const char*) {
+    xml_element empty;
+    return empty;
+  }
+}
+
+}
+
+#endif

snesfilter/nall/ups.hpp

@@ -6,7 +6,6 @@
 #include <nall/algorithm.hpp>
 #include <nall/crc32.hpp>
 #include <nall/file.hpp>
-#include <nall/new.hpp>
 #include <nall/stdint.hpp>
 
 namespace nall {
@@ -98,7 +97,7 @@ namespace nall {
       //mirror
       if(x_size != px_size && x_size != py_size) return input_invalid;
       y_size = (x_size == px_size) ? py_size : px_size;
-      y_data = new(zeromemory) uint8_t[y_size];
+      y_data = new uint8_t[y_size]();
 
       for(unsigned i = 0; i < x_size && i < y_size; i++) y_data[i] = x_data[i];
       for(unsigned i = x_size; i < y_size; i++) y_data[i] = 0x00;

snesfilter/nall/utf8.hpp

@@ -1,20 +1,21 @@
 #ifndef NALL_UTF8_HPP
 #define NALL_UTF8_HPP
 
-#include <nall/new.hpp>
-
 //UTF-8 <> UTF-16 conversion
 //used only for Win32; Linux, etc use UTF-8 internally
 
 #if defined(_WIN32)
 
+#undef _WIN32_WINNT
+#define _WIN32_WINNT 0x0501
 #undef  NOMINMAX
 #define NOMINMAX
 #include <windows.h>
+#undef interface
 
 namespace nall {
   //UTF-8 to UTF-16
-  class utf16 {
+  class utf16_t {
   public:
     operator wchar_t*() {
       return buffer;
@@ -24,14 +25,14 @@ namespace nall {
       return buffer;
     }
 
-    utf16(const char *s = "") {
+    utf16_t(const char *s = "") {
       if(!s) s = "";
       unsigned length = MultiByteToWideChar(CP_UTF8, 0, s, -1, 0, 0);
-      buffer = new(zeromemory) wchar_t[length + 1];
+      buffer = new wchar_t[length + 1]();
       MultiByteToWideChar(CP_UTF8, 0, s, -1, buffer, length);
     }
 
-    ~utf16() {
+    ~utf16_t() {
       delete[] buffer;
     }
 
@@ -40,7 +41,7 @@ namespace nall {
   };
 
   //UTF-16 to UTF-8
-  class utf8 {
+  class utf8_t {
   public:
     operator char*() {
       return buffer;
@@ -50,14 +51,14 @@ namespace nall {
       return buffer;
     }
 
-    utf8(const wchar_t *s = L"") {
+    utf8_t(const wchar_t *s = L"") {
       if(!s) s = L"";
       unsigned length = WideCharToMultiByte(CP_UTF8, 0, s, -1, 0, 0, (const char*)0, (BOOL*)0);
-      buffer = new(zeromemory) char[length + 1];
+      buffer = new char[length + 1]();
       WideCharToMultiByte(CP_UTF8, 0, s, -1, buffer, length, (const char*)0, (BOOL*)0);
     }
 
-    ~utf8() {
+    ~utf8_t() {
       delete[] buffer;
     }
 

snesfilter/nall/utility.hpp

@@ -0,0 +1,39 @@
+#ifndef NALL_UTILITY_HPP
+#define NALL_UTILITY_HPP
+
+#include <type_traits>
+#include <utility>
+
+namespace nall {
+  template<bool C, typename T = bool> struct enable_if { typedef T type; };
+  template<typename T> struct enable_if<false, T> {};
+  template<typename C, typename T = bool> struct mp_enable_if : enable_if<C::value, T> {};
+
+  template<typename T> inline void swap(T &x, T &y) {
+    T temp(std::move(x));
+    x = std::move(y);
+    y = std::move(temp);
+  }
+
+  template<typename T> struct base_from_member {
+    T value;
+    base_from_member(T value_) : value(value_) {}
+  };
+
+  template<typename T> class optional {
+    bool valid;
+    T value;
+  public:
+    inline operator bool() const { return valid; }
+    inline const T& operator()() const { if(!valid) throw; return value; }
+    inline optional(bool valid, const T &value) : valid(valid), value(value) {}
+  };
+
+  template<typename T> inline T* allocate(unsigned size, const T &value) {
+    T *array = new T[size];
+    for(unsigned i = 0; i < size; i++) array[i] = value;
+    return array;
+  }
+}
+
+#endif

snesfilter/nall/vector.hpp

@@ -1,9 +1,14 @@
 #ifndef NALL_VECTOR_HPP
 #define NALL_VECTOR_HPP
 
+#include <initializer_list>
 #include <new>
+#include <type_traits>
+#include <utility>
 #include <nall/algorithm.hpp>
 #include <nall/bit.hpp>
+#include <nall/concept.hpp>
+#include <nall/foreach.hpp>
 #include <nall/utility.hpp>
 
 namespace nall {
@@ -19,7 +24,7 @@ namespace nall {
   //if objects hold memory address references to themselves (introspection), a
   //valid copy constructor will be needed to keep pointers valid.
 
-  template<typename T> class linear_vector : noncopyable {
+  template<typename T> class linear_vector {
   protected:
     T *pool;
     unsigned poolsize, objectsize;
@@ -64,11 +69,31 @@ namespace nall {
       objectsize = newsize;
     }
 
-    void add(const T data) {
+    void append(const T data) {
       if(objectsize + 1 > poolsize) reserve(objectsize + 1);
       new(pool + objectsize++) T(data);
     }
 
+    template<typename U> void insert(unsigned index, const U list) {
+      linear_vector<T> merged;
+      for(unsigned i = 0; i < index; i++) merged.append(pool[i]);
+      foreach(item, list) merged.append(item);
+      for(unsigned i = index; i < objectsize; i++) merged.append(pool[i]);
+      operator=(merged);
+    }
+
+    void insert(unsigned index, const T item) {
+      insert(index, linear_vector<T>{ item });
+    }
+
+    void remove(unsigned index, unsigned count = 1) {
+      for(unsigned i = index; count + i < objectsize; i++) {
+        pool[i] = pool[count + i];
+      }
+      if(count + index >= objectsize) resize(index);  //every element >= index was removed
+      else resize(objectsize - count);
+    }
+
     inline T& operator[](unsigned index) {
       if(index >= objectsize) resize(index + 1);
       return pool[index];
@@ -79,8 +104,45 @@ namespace nall {
       return pool[index];
     }
 
-    linear_vector() : pool(0), poolsize(0), objectsize(0) {}
-    ~linear_vector() { reset(); }
+    //copy
+    inline linear_vector<T>& operator=(const linear_vector<T> &source) {
+      reset();
+      reserve(source.capacity());
+      resize(source.size());
+      for(unsigned i = 0; i < source.size(); i++) operator[](i) = source.operator[](i);
+      return *this;
+    }
+
+    linear_vector(const linear_vector<T> &source) : pool(0), poolsize(0), objectsize(0) {
+      operator=(source);
+    }
+
+    //move
+    inline linear_vector<T>& operator=(linear_vector<T> &&source) {
+      reset();
+      pool = source.pool;
+      poolsize = source.poolsize;
+      objectsize = source.objectsize;
+      source.pool = 0;
+      source.reset();
+      return *this;
+    }
+
+    linear_vector(linear_vector<T> &&source) : pool(0), poolsize(0), objectsize(0) {
+      operator=(std::move(source));
+    }
+
+    //construction
+    linear_vector() : pool(0), poolsize(0), objectsize(0) {
+    }
+
+    linear_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
+    }
+
+    ~linear_vector() {
+      reset();
+    }
   };
 
   //pointer_vector
@@ -93,7 +155,7 @@ namespace nall {
   //by guaranteeing that the base memory address of each objects never changes,
   //this avoids the need for an object to have a valid copy constructor.
 
-  template<typename T> class pointer_vector : noncopyable {
+  template<typename T> class pointer_vector {
   protected:
     T **pool;
     unsigned poolsize, objectsize;
@@ -135,11 +197,31 @@ namespace nall {
       objectsize = newsize;
     }
 
-    void add(const T data) {
+    void append(const T data) {
       if(objectsize + 1 > poolsize) reserve(objectsize + 1);
       pool[objectsize++] = new T(data);
     }
 
+    template<typename U> void insert(unsigned index, const U list) {
+      pointer_vector<T> merged;
+      for(unsigned i = 0; i < index; i++) merged.append(*pool[i]);
+      foreach(item, list) merged.append(item);
+      for(unsigned i = index; i < objectsize; i++) merged.append(*pool[i]);
+      operator=(merged);
+    }
+
+    void insert(unsigned index, const T item) {
+      insert(index, pointer_vector<T>{ item });
+    }
+
+    void remove(unsigned index, unsigned count = 1) {
+      for(unsigned i = index; count + i < objectsize; i++) {
+        *pool[i] = *pool[count + i];
+      }
+      if(count + index >= objectsize) resize(index);  //every element >= index was removed
+      else resize(objectsize - count);
+    }
+
     inline T& operator[](unsigned index) {
       if(index >= objectsize) resize(index + 1);
       if(!pool[index]) pool[index] = new T;
@@ -151,12 +233,49 @@ namespace nall {
       return *pool[index];
     }
 
-    pointer_vector() : pool(0), poolsize(0), objectsize(0) {}
-    ~pointer_vector() { reset(); }
+    //copy
+    inline pointer_vector<T>& operator=(const pointer_vector<T> &source) {
+      reset();
+      reserve(source.capacity());
+      resize(source.size());
+      for(unsigned i = 0; i < source.size(); i++) operator[](i) = source.operator[](i);
+      return *this;
+    }
+
+    pointer_vector(const pointer_vector<T> &source) : pool(0), poolsize(0), objectsize(0) {
+      operator=(source);
+    }
+
+    //move
+    inline pointer_vector<T>& operator=(pointer_vector<T> &&source) {
+      reset();
+      pool = source.pool;
+      poolsize = source.poolsize;
+      objectsize = source.objectsize;
+      source.pool = 0;
+      source.reset();
+      return *this;
+    }
+
+    pointer_vector(pointer_vector<T> &&source) : pool(0), poolsize(0), objectsize(0) {
+      operator=(std::move(source));
+    }
+
+    //construction
+    pointer_vector() : pool(0), poolsize(0), objectsize(0) {
+    }
+
+    pointer_vector(std::initializer_list<T> list) : pool(0), poolsize(0), objectsize(0) {
+      for(const T *p = list.begin(); p != list.end(); ++p) append(*p);
+    }
+
+    ~pointer_vector() {
+      reset();
+    }
   };
 
-  //default vector type
-  template<typename T> class vector : public linear_vector<T> {};
+  template<typename T> struct has_size<linear_vector<T>> { enum { value = true }; };
+  template<typename T> struct has_size<pointer_vector<T>> { enum { value = true }; };
 }
 
 #endif

snesfilter/ntsc/ntsc.cpp

@@ -0,0 +1,380 @@
+#include "snes_ntsc/snes_ntsc.h"
+#include "snes_ntsc/snes_ntsc.c"
+
+#include "ntsc.moc.hpp"
+#include "ntsc.moc"
+
+void NTSCFilter::bind(configuration &config) {
+  config.attach(hue         =  0.0, "snesfilter.ntsc.hue");
+  config.attach(saturation  =  0.0, "snesfilter.ntsc.saturation");
+  config.attach(contrast    =  0.0, "snesfilter.ntsc.contrast");
+  config.attach(brightness  =  0.0, "snesfilter.ntsc.brightness");
+  config.attach(sharpness   =  0.0, "snesfilter.ntsc.sharpness");
+  config.attach(gamma       =  0.0, "snesfilter.ntsc.gamma");
+  config.attach(resolution  =  0.0, "snesfilter.ntsc.resolution");
+  config.attach(artifacts   =  0.0, "snesfilter.ntsc.artifacts");
+  config.attach(fringing    =  0.0, "snesfilter.ntsc.fringing");
+  config.attach(bleed       =  0.0, "snesfilter.ntsc.bleed");
+  config.attach(mergeFields = true, "snesfilter.ntsc.mergeFields");
+}
+
+void NTSCFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  outwidth  = SNES_NTSC_OUT_WIDTH(256);
+  outheight = height;
+}
+
+void NTSCFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  if(!ntsc) return;
+
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  if(width <= 256) {
+    snes_ntsc_blit      (ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  } else {
+    snes_ntsc_blit_hires(ntsc, input, pitch, burst, width, height, output, outpitch << 2);
+  }
+
+  burst ^= burst_toggle;
+}
+
+QWidget* NTSCFilter::settings() {
+  if(!widget) {
+    widget = new QWidget;
+    widget->setWindowTitle("NTSC Filter Configuration");
+
+    layout = new QVBoxLayout;
+    layout->setAlignment(Qt::AlignTop);
+    widget->setLayout(layout);
+
+    gridLayout = new QGridLayout;
+    layout->addLayout(gridLayout);
+
+    basicSettings = new QLabel("<b>Basic settings:</b>");
+    gridLayout->addWidget(basicSettings, 0, 0, 1, 3);
+
+    hueLabel = new QLabel("Hue:");
+    gridLayout->addWidget(hueLabel, 1, 0);
+
+    hueValue = new QLabel;
+    hueValue->setMinimumWidth(hueValue->fontMetrics().width("-100.0"));
+    hueValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(hueValue, 1, 1);
+
+    hueSlider = new QSlider(Qt::Horizontal);
+    hueSlider->setMinimum(-100);
+    hueSlider->setMaximum(+100);
+    gridLayout->addWidget(hueSlider, 1, 2);
+
+    saturationLabel = new QLabel("Saturation:");
+    gridLayout->addWidget(saturationLabel, 2, 0);
+
+    saturationValue = new QLabel;
+    saturationValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(saturationValue, 2, 1);
+
+    saturationSlider = new QSlider(Qt::Horizontal);
+    saturationSlider->setMinimum(-100);
+    saturationSlider->setMaximum(+100);
+    gridLayout->addWidget(saturationSlider, 2, 2);
+
+    contrastLabel = new QLabel("Contrast:");
+    gridLayout->addWidget(contrastLabel, 3, 0);
+
+    contrastValue = new QLabel;
+    contrastValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(contrastValue, 3, 1);
+
+    contrastSlider = new QSlider(Qt::Horizontal);
+    contrastSlider->setMinimum(-100);
+    contrastSlider->setMaximum(+100);
+    gridLayout->addWidget(contrastSlider, 3, 2);
+
+    brightnessLabel = new QLabel("Brightness:");
+    gridLayout->addWidget(brightnessLabel, 4, 0);
+
+    brightnessValue = new QLabel;
+    brightnessValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(brightnessValue, 4, 1);
+
+    brightnessSlider = new QSlider(Qt::Horizontal);
+    brightnessSlider->setMinimum(-100);
+    brightnessSlider->setMaximum(+100);
+    gridLayout->addWidget(brightnessSlider, 4, 2);
+
+    sharpnessLabel = new QLabel("Sharpness:");
+    gridLayout->addWidget(sharpnessLabel, 5, 0);
+
+    sharpnessValue = new QLabel;
+    sharpnessValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(sharpnessValue, 5, 1);
+
+    sharpnessSlider = new QSlider(Qt::Horizontal);
+    sharpnessSlider->setMinimum(-100);
+    sharpnessSlider->setMaximum(+100);
+    gridLayout->addWidget(sharpnessSlider, 5, 2);
+
+    advancedSettings = new QLabel("<b>Advanced settings:</b>");
+    gridLayout->addWidget(advancedSettings, 6, 0, 1, 3);
+
+    gammaLabel = new QLabel("Gamma:");
+    gridLayout->addWidget(gammaLabel, 7, 0);
+
+    gammaValue = new QLabel;
+    gammaValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(gammaValue, 7, 1);
+
+    gammaSlider = new QSlider(Qt::Horizontal);
+    gammaSlider->setMinimum(-100);
+    gammaSlider->setMaximum(+100);
+    gridLayout->addWidget(gammaSlider, 7, 2);
+
+    resolutionLabel = new QLabel("Resolution:");
+    gridLayout->addWidget(resolutionLabel, 8, 0);
+
+    resolutionValue = new QLabel;
+    resolutionValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(resolutionValue, 8, 1);
+
+    resolutionSlider = new QSlider(Qt::Horizontal);
+    resolutionSlider->setMinimum(-100);
+    resolutionSlider->setMaximum(+100);
+    gridLayout->addWidget(resolutionSlider, 8, 2);
+
+    artifactsLabel = new QLabel("Artifacts:");
+    gridLayout->addWidget(artifactsLabel, 9, 0);
+
+    artifactsValue = new QLabel;
+    artifactsValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(artifactsValue, 9, 1);
+
+    artifactsSlider = new QSlider(Qt::Horizontal);
+    artifactsSlider->setMinimum(-100);
+    artifactsSlider->setMaximum(+100);
+    gridLayout->addWidget(artifactsSlider, 9, 2);
+
+    fringingLabel = new QLabel("Fringing:");
+    gridLayout->addWidget(fringingLabel, 10, 0);
+
+    fringingValue = new QLabel;
+    fringingValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(fringingValue, 10, 1);
+
+    fringingSlider = new QSlider(Qt::Horizontal);
+    fringingSlider->setMinimum(-100);
+    fringingSlider->setMaximum(+100);
+    gridLayout->addWidget(fringingSlider, 10, 2);
+
+    bleedLabel = new QLabel("Color bleed:");
+    gridLayout->addWidget(bleedLabel, 11, 0);
+
+    bleedValue = new QLabel;
+    bleedValue->setAlignment(Qt::AlignHCenter);
+    gridLayout->addWidget(bleedValue, 11, 1);
+
+    bleedSlider = new QSlider(Qt::Horizontal);
+    bleedSlider->setMinimum(-100);
+    bleedSlider->setMaximum(+100);
+    gridLayout->addWidget(bleedSlider, 11, 2);
+
+    mergeFieldsBox = new QCheckBox("Merge even and odd fields to reduce flicker");
+    gridLayout->addWidget(mergeFieldsBox, 12, 0, 1, 3);
+
+    presets = new QLabel("<b>Presets:</b>");
+    gridLayout->addWidget(presets, 13, 0, 1, 3);
+
+    controlLayout = new QHBoxLayout;
+    layout->addLayout(controlLayout);
+
+    rfPreset = new QPushButton("RF");
+    controlLayout->addWidget(rfPreset);
+
+    compositePreset = new QPushButton("Composite");
+    controlLayout->addWidget(compositePreset);
+
+    svideoPreset = new QPushButton("S-Video");
+    controlLayout->addWidget(svideoPreset);
+
+    rgbPreset = new QPushButton("RGB");
+    controlLayout->addWidget(rgbPreset);
+
+    monoPreset = new QPushButton("Monochrome");
+    controlLayout->addWidget(monoPreset);
+
+    spacer = new QWidget;
+    spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
+    spacer->setMinimumWidth(50);
+    controlLayout->addWidget(spacer);
+
+    ok = new QPushButton("Ok");
+    controlLayout->addWidget(ok);
+
+    blockSignals = true;
+    loadSettingsFromConfig();
+    syncUiToSettings();
+    initialize();
+
+    connect(hueSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(saturationSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(contrastSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(brightnessSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(sharpnessSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(gammaSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(resolutionSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(artifactsSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(fringingSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(bleedSlider, SIGNAL(valueChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(mergeFieldsBox, SIGNAL(stateChanged(int)), this, SLOT(syncSettingsToUi()));
+    connect(rfPreset, SIGNAL(released()), this, SLOT(setRfPreset()));
+    connect(compositePreset, SIGNAL(released()), this, SLOT(setCompositePreset()));
+    connect(svideoPreset, SIGNAL(released()), this, SLOT(setSvideoPreset()));
+    connect(rgbPreset, SIGNAL(released()), this, SLOT(setRgbPreset()));
+    connect(monoPreset, SIGNAL(released()), this, SLOT(setMonoPreset()));
+    connect(ok, SIGNAL(released()), widget, SLOT(hide()));
+
+    blockSignals = false;
+  }
+
+  return widget;
+}
+
+void NTSCFilter::initialize() {
+  burst = 0;
+  burst_toggle = (setup.merge_fields ? 0 : 1);  //don't toggle burst when fields are merged
+  snes_ntsc_init(ntsc, &setup);
+}
+
+void NTSCFilter::loadSettingsFromConfig() {
+  setup.hue = hue;
+  setup.saturation = saturation;
+  setup.contrast = contrast;
+  setup.brightness = brightness;
+  setup.sharpness = sharpness;
+
+  setup.gamma = gamma;
+  setup.resolution = resolution;
+  setup.artifacts = artifacts;
+  setup.fringing = fringing;
+  setup.bleed = bleed;
+
+  setup.merge_fields = mergeFields;
+}
+
+void NTSCFilter::syncUiToSettings() {
+  blockSignals = true;
+
+  hue = setup.hue;
+  saturation = setup.saturation;
+  contrast = setup.contrast;
+  brightness = setup.brightness;
+  sharpness = setup.sharpness;
+
+  gamma = setup.gamma;
+  resolution = setup.resolution;
+  artifacts = setup.artifacts;
+  fringing = setup.fringing;
+  bleed = setup.bleed;
+
+  mergeFields = setup.merge_fields;
+
+  hueValue->setText(string() << hue);
+  hueSlider->setSliderPosition(hue * 100);
+
+  saturationValue->setText(string() << saturation);
+  saturationSlider->setSliderPosition(saturation * 100);
+
+  contrastValue->setText(string() << contrast);
+  contrastSlider->setSliderPosition(contrast * 100);
+
+  brightnessValue->setText(string() << brightness);
+  brightnessSlider->setSliderPosition(brightness * 100);
+
+  sharpnessValue->setText(string() << sharpness);
+  sharpnessSlider->setSliderPosition(sharpness * 100);
+
+  gammaValue->setText(string() << gamma);
+  gammaSlider->setSliderPosition(gamma * 100);
+
+  resolutionValue->setText(string() << resolution);
+  resolutionSlider->setSliderPosition(resolution * 100);
+
+  artifactsValue->setText(string() << artifacts);
+  artifactsSlider->setSliderPosition(artifacts * 100);
+
+  fringingValue->setText(string() << fringing);
+  fringingSlider->setSliderPosition(fringing * 100);
+
+  bleedValue->setText(string() << bleed);
+  bleedSlider->setSliderPosition(bleed * 100);
+
+  mergeFieldsBox->setChecked(mergeFields);
+
+  blockSignals = false;
+}
+
+void NTSCFilter::syncSettingsToUi() {
+  if(blockSignals) return;
+
+  hue = hueSlider->sliderPosition() / 100.0;
+  saturation = saturationSlider->sliderPosition() / 100.0;
+  contrast = contrastSlider->sliderPosition() / 100.0;
+  brightness = brightnessSlider->sliderPosition() / 100.0;
+  sharpness = sharpnessSlider->sliderPosition() / 100.0;
+
+  gamma = gammaSlider->sliderPosition() / 100.0;
+  resolution = resolutionSlider->sliderPosition() / 100.0;
+  artifacts = artifactsSlider->sliderPosition() / 100.0;
+  fringing = fringingSlider->sliderPosition() / 100.0;
+  bleed = bleedSlider->sliderPosition() / 100.0;
+
+  mergeFields = mergeFieldsBox->isChecked();
+
+  loadSettingsFromConfig();
+  syncUiToSettings();
+  initialize();
+}
+
+void NTSCFilter::setRfPreset() {
+  static snes_ntsc_setup_t defaults;
+  setup = defaults;
+  syncUiToSettings();
+  initialize();
+}
+
+void NTSCFilter::setCompositePreset() {
+  setup = snes_ntsc_composite;
+  syncUiToSettings();
+  initialize();
+}
+
+void NTSCFilter::setSvideoPreset() {
+  setup = snes_ntsc_svideo;
+  syncUiToSettings();
+  initialize();
+}
+
+void NTSCFilter::setRgbPreset() {
+  setup = snes_ntsc_rgb;
+  syncUiToSettings();
+  initialize();
+}
+
+void NTSCFilter::setMonoPreset() {
+  setup = snes_ntsc_monochrome;
+  syncUiToSettings();
+  initialize();
+}
+
+NTSCFilter::NTSCFilter() : widget(0) {
+  ntsc = (snes_ntsc_t*)malloc(sizeof *ntsc);
+  static snes_ntsc_setup_t defaults;
+  setup = defaults;
+  initialize();
+}
+
+NTSCFilter::~NTSCFilter() {
+  if(ntsc) free(ntsc);
+}

snesfilter/ntsc/ntsc.moc.hpp

@@ -0,0 +1,91 @@
+class NTSCFilter : public QObject {
+  Q_OBJECT
+
+public:
+  void bind(configuration&);
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+  QWidget* settings();
+
+  NTSCFilter();
+  ~NTSCFilter();
+
+private:
+  void initialize();
+  void loadSettingsFromConfig();
+  void syncUiToSettings();
+
+private slots:
+  void syncSettingsToUi();
+  void setRfPreset();
+  void setCompositePreset();
+  void setSvideoPreset();
+  void setRgbPreset();
+  void setMonoPreset();
+
+private:
+  QWidget *widget;
+  QVBoxLayout *layout;
+  QGridLayout *gridLayout;
+  QLabel *basicSettings;
+  QLabel *hueLabel;
+  QLabel *hueValue;
+  QSlider *hueSlider;
+  QLabel *saturationLabel;
+  QLabel *saturationValue;
+  QSlider *saturationSlider;
+  QLabel *contrastLabel;
+  QLabel *contrastValue;
+  QSlider *contrastSlider;
+  QLabel *brightnessLabel;
+  QLabel *brightnessValue;
+  QSlider *brightnessSlider;
+  QLabel *sharpnessLabel;
+  QLabel *sharpnessValue;
+  QSlider *sharpnessSlider;
+  QLabel *advancedSettings;
+  QLabel *gammaLabel;
+  QLabel *gammaValue;
+  QSlider *gammaSlider;
+  QLabel *resolutionLabel;
+  QLabel *resolutionValue;
+  QSlider *resolutionSlider;
+  QLabel *artifactsLabel;
+  QLabel *artifactsValue;
+  QSlider *artifactsSlider;
+  QLabel *fringingLabel;
+  QLabel *fringingValue;
+  QSlider *fringingSlider;
+  QLabel *bleedLabel;
+  QLabel *bleedValue;
+  QSlider *bleedSlider;
+  QCheckBox *mergeFieldsBox;
+  QLabel *presets;
+  QHBoxLayout *controlLayout;
+  QPushButton *rfPreset;
+  QPushButton *compositePreset;
+  QPushButton *svideoPreset;
+  QPushButton *rgbPreset;
+  QPushButton *monoPreset;
+  QWidget *spacer;
+  QPushButton *ok;
+
+  bool blockSignals;
+
+  struct snes_ntsc_t *ntsc;
+  snes_ntsc_setup_t setup;
+  int burst, burst_toggle;
+
+  //settings
+  double hue;
+  double saturation;
+  double contrast;
+  double brightness;
+  double sharpness;
+  double gamma;
+  double resolution;
+  double artifacts;
+  double fringing;
+  double bleed;
+  bool mergeFields;
+} filter_ntsc;

snesfilter/pixellate2x/pixellate2x.cpp

@@ -0,0 +1,38 @@
+#include "pixellate2x.hpp"
+
+void Pixellate2xFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  outwidth  = (width  <= 256) ? width  * 2 : width;
+  outheight = (height <= 240) ? height * 2 : height;
+}
+
+void Pixellate2xFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  uint32_t *out0 = output;
+  uint32_t *out1 = output + outpitch;
+
+  for(unsigned y = 0; y < height; y++) {
+    for(unsigned x = 0; x < width; x++) {
+      uint32_t p = colortable[*input++];
+
+      *out0++ = p;
+      if(height <= 240) *out1++ = p;
+      if(width > 256) continue;
+
+      *out0++ = p;
+      if(height <= 240) *out1++ = p;
+    }
+
+    input += pitch - width;
+    if(height <= 240) {
+      out0 += outpitch + outpitch - 512;
+      out1 += outpitch + outpitch - 512;
+    } else {
+      out0 += outpitch - 512;
+    }
+  }
+}

snesfilter/pixellate2x/pixellate2x.hpp

@@ -0,0 +1,5 @@
+class Pixellate2xFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+} filter_pixellate2x;

snesfilter/scale2x/scale2x.cpp

@@ -0,0 +1,53 @@
+#include "scale2x.hpp"
+
+void Scale2xFilter::size(unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  if(width > 256 || height > 240) return filter_direct.size(outwidth, outheight, width, height);
+  outwidth  = width  * 2;
+  outheight = height * 2;
+}
+
+void Scale2xFilter::render(
+  uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  if(width > 256 || height > 240) {
+    filter_direct.render(output, outpitch, input, pitch, width, height);
+    return;
+  }
+
+  pitch >>= 1;
+  outpitch >>= 2;
+
+  uint32_t *out0 = output;
+  uint32_t *out1 = output + outpitch;
+
+  for(unsigned y = 0; y < height; y++) {
+    int prevline = (y == 0 ? 0 : pitch);
+    int nextline = (y == height - 1 ? 0 : pitch);
+
+    for(unsigned x = 0; x < width; x++) {
+      uint16_t A = *(input - prevline);
+      uint16_t B = (x >   0) ? *(input - 1) : *input;
+      uint16_t C = *input;
+      uint16_t D = (x < 255) ? *(input + 1) : *input;
+      uint16_t E = *(input++ + nextline);
+      uint32_t c = colortable[C];
+
+      if(A != E && B != D) {
+        *out0++ = (A == B ? colortable[A] : c);
+        *out0++ = (A == D ? colortable[A] : c);
+        *out1++ = (E == B ? colortable[E] : c);
+        *out1++ = (E == D ? colortable[E] : c);
+      } else {
+        *out0++ = c;
+        *out0++ = c;
+        *out1++ = c;
+        *out1++ = c;
+      }
+    }
+
+    input += pitch - width;
+    out0 += outpitch + outpitch - 512;
+    out1 += outpitch + outpitch - 512;
+  }
+}

snesfilter/scale2x/scale2x.hpp

@@ -0,0 +1,5 @@
+class Scale2xFilter {
+public:
+  void size(unsigned&, unsigned&, unsigned, unsigned);
+  void render(uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+} filter_scale2x;

snesfilter/snesfilter.cpp

@@ -0,0 +1,83 @@
+#include "snesfilter.hpp"
+
+#if defined(_WIN32)
+  #define dllexport __declspec(dllexport)
+#else
+  #define dllexport
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define QT_CORE_LIB
+#include <QtGui>
+
+#include <nall/config.hpp>
+#include <nall/platform.hpp>
+#include <nall/string.hpp>
+using namespace nall;
+
+const uint32_t *colortable;
+configuration *config;
+
+#include "direct/direct.cpp"
+#include "pixellate2x/pixellate2x.cpp"
+#include "scale2x/scale2x.cpp"
+#include "2xsai/2xsai.cpp"
+#include "lq2x/lq2x.cpp"
+#include "hq2x/hq2x.cpp"
+#include "ntsc/ntsc.cpp"
+
+dllexport const char* snesfilter_supported() {
+  return "Pixellate2x;Scale2x;2xSaI;Super 2xSaI;Super Eagle;LQ2x;HQ2x;NTSC";
+}
+
+dllexport void snesfilter_configuration(configuration &config_) {
+  config = &config_;
+  if(config) {
+    filter_ntsc.bind(*config);
+  }
+}
+
+dllexport void snesfilter_colortable(const uint32_t *colortable_) {
+  colortable = colortable_;
+}
+
+dllexport void snesfilter_size(unsigned filter, unsigned &outwidth, unsigned &outheight, unsigned width, unsigned height) {
+  switch(filter) {
+    default: return filter_direct.size(outwidth, outheight, width, height);
+    case 1:  return filter_pixellate2x.size(outwidth, outheight, width, height);
+    case 2:  return filter_scale2x.size(outwidth, outheight, width, height);
+    case 3:  return filter_2xsai.size(outwidth, outheight, width, height);
+    case 4:  return filter_super2xsai.size(outwidth, outheight, width, height);
+    case 5:  return filter_supereagle.size(outwidth, outheight, width, height);
+    case 6:  return filter_lq2x.size(outwidth, outheight, width, height);
+    case 7:  return filter_hq2x.size(outwidth, outheight, width, height);
+    case 8:  return filter_ntsc.size(outwidth, outheight, width, height);
+  }
+}
+
+dllexport void snesfilter_render(
+  unsigned filter, uint32_t *output, unsigned outpitch,
+  const uint16_t *input, unsigned pitch, unsigned width, unsigned height
+) {
+  switch(filter) {
+    default: return filter_direct.render(output, outpitch, input, pitch, width, height);
+    case 1:  return filter_pixellate2x.render(output, outpitch, input, pitch, width, height);
+    case 2:  return filter_scale2x.render(output, outpitch, input, pitch, width, height);
+    case 3:  return filter_2xsai.render(output, outpitch, input, pitch, width, height);
+    case 4:  return filter_super2xsai.render(output, outpitch, input, pitch, width, height);
+    case 5:  return filter_supereagle.render(output, outpitch, input, pitch, width, height);
+    case 6:  return filter_lq2x.render(output, outpitch, input, pitch, width, height);
+    case 7:  return filter_hq2x.render(output, outpitch, input, pitch, width, height);
+    case 8:  return filter_ntsc.render(output, outpitch, input, pitch, width, height);
+  }
+}
+
+dllexport QWidget* snesfilter_settings(unsigned filter) {
+  switch(filter) {
+    default: return 0;
+    case 8:  return filter_ntsc.settings();
+  }
+}

snesfilter/snesfilter.hpp

@@ -0,0 +1,12 @@
+#include <stdint.h>
+class QWidget;
+namespace nall { class configuration; }
+
+extern "C" {
+  const char* snesfilter_supported();
+  void snesfilter_configuration(nall::configuration&);
+  void snesfilter_colortable(const uint32_t*);
+  void snesfilter_size(unsigned, unsigned&, unsigned&, unsigned, unsigned);
+  void snesfilter_render(unsigned, uint32_t*, unsigned, const uint16_t*, unsigned, unsigned, unsigned);
+  QWidget* snesfilter_settings(unsigned);
+}

snesfilter/sync.sh

@@ -0,0 +1,2 @@
+rm -r nall
+cp -r ../nall ./nall

snesreader/7z_C/7zAlloc.c

@@ -0,0 +1,77 @@
+/* 7zAlloc.c -- Allocation functions
+2008-10-04 : Igor Pavlov : Public domain */
+
+#include <stdlib.h>
+#include "7zAlloc.h"
+
+/* #define _SZ_ALLOC_DEBUG */
+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */
+
+#ifdef _SZ_ALLOC_DEBUG
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include <stdio.h>
+int g_allocCount = 0;
+int g_allocCountTemp = 0;
+
+#endif
+
+void *SzAlloc(void *p, size_t size)
+{
+  p = p;
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount);
+  g_allocCount++;
+  #endif
+  return malloc(size);
+}
+
+void SzFree(void *p, void *address)
+{
+  p = p;
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+  {
+    g_allocCount--;
+    fprintf(stderr, "\nFree; count = %10d", g_allocCount);
+  }
+  #endif
+  free(address);
+}
+
+void *SzAllocTemp(void *p, size_t size)
+{
+  p = p;
+  if (size == 0)
+    return 0;
+  #ifdef _SZ_ALLOC_DEBUG
+  fprintf(stderr, "\nAlloc_temp %10d bytes;  count = %10d", size, g_allocCountTemp);
+  g_allocCountTemp++;
+  #ifdef _WIN32
+  return HeapAlloc(GetProcessHeap(), 0, size);
+  #endif
+  #endif
+  return malloc(size);
+}
+
+void SzFreeTemp(void *p, void *address)
+{
+  p = p;
+  #ifdef _SZ_ALLOC_DEBUG
+  if (address != 0)
+  {
+    g_allocCountTemp--;
+    fprintf(stderr, "\nFree_temp; count = %10d", g_allocCountTemp);
+  }
+  #ifdef _WIN32
+  HeapFree(GetProcessHeap(), 0, address);
+  return;
+  #endif
+  #endif
+  free(address);
+}

snesreader/7z_C/7zAlloc.h

@@ -0,0 +1,23 @@
+/* 7zAlloc.h -- Allocation functions
+2008-10-04 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_ALLOC_H
+#define __7Z_ALLOC_H
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+void *SzAlloc(void *p, size_t size);
+void SzFree(void *p, void *address);
+
+void *SzAllocTemp(void *p, size_t size);
+void SzFreeTemp(void *p, void *address);
+
+#ifdef __cplusplus
+	}
+#endif
+
+#endif

snesreader/7z_C/7zBuf.c

@@ -0,0 +1,36 @@
+/* 7zBuf.c -- Byte Buffer
+2008-03-28
+Igor Pavlov
+Public domain */
+
+#include "7zBuf.h"
+
+void Buf_Init(CBuf *p)
+{
+  p->data = 0;
+  p->size = 0;
+}
+
+int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc)
+{
+  p->size = 0;
+  if (size == 0)
+  {
+    p->data = 0;
+    return 1;
+  }
+  p->data = (Byte *)alloc->Alloc(alloc, size);
+  if (p->data != 0)
+  {
+    p->size = size;
+    return 1;
+  }
+  return 0;
+}
+
+void Buf_Free(CBuf *p, ISzAlloc *alloc)
+{
+  alloc->Free(alloc, p->data);
+  p->data = 0;
+  p->size = 0;
+}

snesreader/7z_C/7zBuf.h

@@ -0,0 +1,31 @@
+/* 7zBuf.h -- Byte Buffer
+2008-10-04 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_BUF_H
+#define __7Z_BUF_H
+
+#include "Types.h"
+
+typedef struct
+{
+  Byte *data;
+  size_t size;
+} CBuf;
+
+void Buf_Init(CBuf *p);
+int Buf_Create(CBuf *p, size_t size, ISzAlloc *alloc);
+void Buf_Free(CBuf *p, ISzAlloc *alloc);
+
+typedef struct
+{
+  Byte *data;
+  size_t size;
+  size_t pos;
+} CDynBuf;
+
+void DynBuf_Construct(CDynBuf *p);
+void DynBuf_SeekToBeg(CDynBuf *p);
+int DynBuf_Write(CDynBuf *p, const Byte *buf, size_t size, ISzAlloc *alloc);
+void DynBuf_Free(CDynBuf *p, ISzAlloc *alloc);
+
+#endif

snesreader/7z_C/7zC.txt

@@ -0,0 +1,194 @@
+7z ANSI-C Decoder 4.62
+----------------------
+
+7z ANSI-C provides 7z/LZMA decoding.
+7z ANSI-C version is simplified version ported from C++ code.
+
+LZMA is default and general compression method of 7z format
+in 7-Zip compression program (www.7-zip.org). LZMA provides high 
+compression ratio and very fast decompression.
+
+
+LICENSE
+-------
+
+7z ANSI-C Decoder is part of the LZMA SDK.
+LZMA SDK is written and placed in the public domain by Igor Pavlov.
+
+Files
+---------------------
+
+7zDecode.*   - Low level 7z decoding
+7zExtract.*  - High level 7z decoding
+7zHeader.*   - .7z format constants
+7zIn.*       - .7z archive opening
+7zItem.*     - .7z structures
+7zMain.c     - Test application
+
+
+How To Use
+----------
+
+You must download 7-Zip program from www.7-zip.org.
+
+You can create .7z archive with 7z.exe or 7za.exe:
+
+  7za.exe a archive.7z *.htm -r -mx -m0fb=255
+
+If you have big number of files in archive, and you need fast extracting, 
+you can use partly-solid archives:
+  
+  7za.exe a archive.7z *.htm -ms=512K -r -mx -m0fb=255 -m0d=512K
+
+In that example 7-Zip will use 512KB solid blocks. So it needs to decompress only 
+512KB for extracting one file from such archive.
+
+
+Limitations of current version of 7z ANSI-C Decoder
+---------------------------------------------------
+
+ - It reads only "FileName", "Size", "LastWriteTime" and "CRC" information for each file in archive.
+ - It supports only LZMA and Copy (no compression) methods with BCJ or BCJ2 filters.
+ - It converts original UTF-16 Unicode file names to UTF-8 Unicode file names.
+ 
+These limitations will be fixed in future versions.
+
+
+Using 7z ANSI-C Decoder Test application:
+-----------------------------------------
+
+Usage: 7zDec <command> <archive_name>
+
+<Command>:
+  e: Extract files from archive
+  l: List contents of archive
+  t: Test integrity of archive
+
+Example: 
+
+  7zDec l archive.7z
+
+lists contents of archive.7z
+
+  7zDec e archive.7z
+
+extracts files from archive.7z to current folder.
+
+
+How to use .7z Decoder
+----------------------
+
+Memory allocation
+~~~~~~~~~~~~~~~~~
+
+7z Decoder uses two memory pools:
+1) Temporary pool
+2) Main pool
+Such scheme can allow you to avoid fragmentation of allocated blocks.
+
+
+Steps for using 7z decoder
+--------------------------
+
+Use code at 7zMain.c as example.
+
+1) Declare variables:
+  inStream                 /* implements ILookInStream interface */
+  CSzArEx db;              /* 7z archive database structure */
+  ISzAlloc allocImp;       /* memory functions for main pool */
+  ISzAlloc allocTempImp;   /* memory functions for temporary pool */
+
+2) call CrcGenerateTable(); function to initialize CRC structures.
+
+3) call SzArEx_Init(&db); function to initialize db structures.
+
+4) call SzArEx_Open(&db, inStream, &allocMain, &allocTemp) to open archive
+
+This function opens archive "inStream" and reads headers to "db".
+All items in "db" will be allocated with "allocMain" functions.
+SzArEx_Open function allocates and frees temporary structures by "allocTemp" functions.
+
+5) List items or Extract items
+
+  Listing code:
+  ~~~~~~~~~~~~~
+    {
+      UInt32 i;
+      for (i = 0; i < db.db.NumFiles; i++)
+      {
+        CFileItem *f = db.db.Files + i;
+        printf("%10d  %s\n", (int)f->Size, f->Name);
+      }
+    }
+
+  Extracting code:
+  ~~~~~~~~~~~~~~~~
+
+  SZ_RESULT SzAr_Extract(
+    CArchiveDatabaseEx *db,
+    ILookInStream *inStream, 
+    UInt32 fileIndex,         /* index of file */
+    UInt32 *blockIndex,       /* index of solid block */
+    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
+    size_t *outBufferSize,    /* buffer size for output buffer */
+    size_t *offset,           /* offset of stream for required file in *outBuffer */
+    size_t *outSizeProcessed, /* size of file in *outBuffer */
+    ISzAlloc *allocMain,
+    ISzAlloc *allocTemp);
+
+  If you need to decompress more than one file, you can send these values from previous call:
+    blockIndex, 
+    outBuffer, 
+    outBufferSize,
+  You can consider "outBuffer" as cache of solid block. If your archive is solid, 
+  it will increase decompression speed.
+
+  After decompressing you must free "outBuffer":
+  allocImp.Free(outBuffer);
+
+6) call SzArEx_Free(&db, allocImp.Free) to free allocated items in "db".
+
+
+
+
+Memory requirements for .7z decoding 
+------------------------------------
+
+Memory usage for Archive opening:
+  - Temporary pool:
+     - Memory for uncompressed .7z headers
+     - some other temporary blocks
+  - Main pool:
+     - Memory for database: 
+       Estimated size of one file structures in solid archive:
+         - Size (4 or 8 Bytes)
+         - CRC32 (4 bytes)
+         - LastWriteTime (8 bytes)
+         - Some file information (4 bytes)
+         - File Name (variable length) + pointer + allocation structures
+
+Memory usage for archive Decompressing:
+  - Temporary pool:
+     - Memory for LZMA decompressing structures
+  - Main pool:
+     - Memory for decompressed solid block
+     - Memory for temprorary buffers, if BCJ2 fileter is used. Usually these 
+       temprorary buffers can be about 15% of solid block size. 
+  
+
+7z Decoder doesn't allocate memory for compressed blocks. 
+Instead of this, you must allocate buffer with desired 
+size before calling 7z Decoder. Use 7zMain.c as example.
+
+
+Defines
+-------
+
+_SZ_ALLOC_DEBUG   - define it if you want to debug alloc/free operations to stderr.
+
+
+---
+
+http://www.7-zip.org
+http://www.7-zip.org/sdk.html
+http://www.7-zip.org/support.html

snesreader/7z_C/7zCrc.c

@@ -0,0 +1,35 @@
+/* 7zCrc.c -- CRC32 calculation
+2008-08-05
+Igor Pavlov
+Public domain */
+
+#include "7zCrc.h"
+
+#define kCrcPoly 0xEDB88320
+UInt32 g_CrcTable[256];
+
+void MY_FAST_CALL CrcGenerateTable(void)
+{
+  UInt32 i;
+  for (i = 0; i < 256; i++)
+  {
+    UInt32 r = i;
+    int j;
+    for (j = 0; j < 8; j++)
+      r = (r >> 1) ^ (kCrcPoly & ~((r & 1) - 1));
+    g_CrcTable[i] = r;
+  }
+}
+
+UInt32 MY_FAST_CALL CrcUpdate(UInt32 v, const void *data, size_t size)
+{
+  const Byte *p = (const Byte *)data;
+  for (; size > 0 ; size--, p++)
+    v = CRC_UPDATE_BYTE(v, *p);
+  return v;
+}
+
+UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size)
+{
+  return CrcUpdate(CRC_INIT_VAL, data, size) ^ 0xFFFFFFFF;
+}

snesreader/7z_C/7zCrc.h

@@ -0,0 +1,32 @@
+/* 7zCrc.h -- CRC32 calculation
+2008-03-13
+Igor Pavlov
+Public domain */
+
+#ifndef __7Z_CRC_H
+#define __7Z_CRC_H
+
+#include <stddef.h>
+
+#include "Types.h"
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+extern UInt32 g_CrcTable[];
+
+void MY_FAST_CALL CrcGenerateTable(void);
+
+#define CRC_INIT_VAL 0xFFFFFFFF
+#define CRC_GET_DIGEST(crc) ((crc) ^ 0xFFFFFFFF)
+#define CRC_UPDATE_BYTE(crc, b) (g_CrcTable[((crc) ^ (b)) & 0xFF] ^ ((crc) >> 8))
+
+UInt32 MY_FAST_CALL CrcUpdate(UInt32 crc, const void *data, size_t size);
+UInt32 MY_FAST_CALL CrcCalc(const void *data, size_t size);
+
+#ifdef __cplusplus
+	}
+#endif
+
+#endif

snesreader/7z_C/7zDecode.c

@@ -0,0 +1,257 @@
+/* 7zDecode.c -- Decoding from 7z folder
+2008-11-23 : Igor Pavlov : Public domain */
+
+#include <string.h>
+
+#include "Bcj2.h"
+#include "Bra.h"
+#include "LzmaDec.h"
+#include "7zDecode.h"
+
+#define k_Copy 0
+#define k_LZMA 0x30101
+#define k_BCJ 0x03030103
+#define k_BCJ2 0x0303011B
+
+static SRes SzDecodeLzma(CSzCoderInfo *coder, UInt64 inSize, ILookInStream *inStream,
+    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain)
+{
+  CLzmaDec state;
+  SRes res = SZ_OK;
+
+  LzmaDec_Construct(&state);
+  RINOK(LzmaDec_AllocateProbs(&state, coder->Props.data, (unsigned)coder->Props.size, allocMain));
+  state.dic = outBuffer;
+  state.dicBufSize = outSize;
+  LzmaDec_Init(&state);
+
+  for (;;)
+  {
+    Byte *inBuf = NULL;
+    size_t lookahead = (1 << 18);
+    if (lookahead > inSize)
+      lookahead = (size_t)inSize;
+    res = inStream->Look((void *)inStream, (void **)&inBuf, &lookahead);
+    if (res != SZ_OK)
+      break;
+
+    {
+      SizeT inProcessed = (SizeT)lookahead, dicPos = state.dicPos;
+      ELzmaStatus status;
+      res = LzmaDec_DecodeToDic(&state, outSize, inBuf, &inProcessed, LZMA_FINISH_END, &status);
+      lookahead -= inProcessed;
+      inSize -= inProcessed;
+      if (res != SZ_OK)
+        break;
+      if (state.dicPos == state.dicBufSize || (inProcessed == 0 && dicPos == state.dicPos))
+      {
+        if (state.dicBufSize != outSize || lookahead != 0 ||
+            (status != LZMA_STATUS_FINISHED_WITH_MARK &&
+             status != LZMA_STATUS_MAYBE_FINISHED_WITHOUT_MARK))
+          res = SZ_ERROR_DATA;
+        break;
+      }
+      res = inStream->Skip((void *)inStream, inProcessed);
+      if (res != SZ_OK)
+        break;
+    }
+  }
+
+  LzmaDec_FreeProbs(&state, allocMain);
+  return res;
+}
+
+static SRes SzDecodeCopy(UInt64 inSize, ILookInStream *inStream, Byte *outBuffer)
+{
+  while (inSize > 0)
+  {
+    void *inBuf;
+    size_t curSize = (1 << 18);
+    if (curSize > inSize)
+      curSize = (size_t)inSize;
+    RINOK(inStream->Look((void *)inStream, (void **)&inBuf, &curSize));
+    if (curSize == 0)
+      return SZ_ERROR_INPUT_EOF;
+    memcpy(outBuffer, inBuf, curSize);
+    outBuffer += curSize;
+    inSize -= curSize;
+    RINOK(inStream->Skip((void *)inStream, curSize));
+  }
+  return SZ_OK;
+}
+
+#define IS_UNSUPPORTED_METHOD(m) ((m) != k_Copy && (m) != k_LZMA)
+#define IS_UNSUPPORTED_CODER(c) (IS_UNSUPPORTED_METHOD(c.MethodID) || c.NumInStreams != 1 || c.NumOutStreams != 1)
+#define IS_NO_BCJ(c) (c.MethodID != k_BCJ || c.NumInStreams != 1 || c.NumOutStreams != 1)
+#define IS_NO_BCJ2(c) (c.MethodID != k_BCJ2 || c.NumInStreams != 4 || c.NumOutStreams != 1)
+
+static
+SRes CheckSupportedFolder(const CSzFolder *f)
+{
+  if (f->NumCoders < 1 || f->NumCoders > 4)
+    return SZ_ERROR_UNSUPPORTED;
+  if (IS_UNSUPPORTED_CODER(f->Coders[0]))
+    return SZ_ERROR_UNSUPPORTED;
+  if (f->NumCoders == 1)
+  {
+    if (f->NumPackStreams != 1 || f->PackStreams[0] != 0 || f->NumBindPairs != 0)
+      return SZ_ERROR_UNSUPPORTED;
+    return SZ_OK;
+  }
+  if (f->NumCoders == 2)
+  {
+    if (IS_NO_BCJ(f->Coders[1]) ||
+        f->NumPackStreams != 1 || f->PackStreams[0] != 0 ||
+        f->NumBindPairs != 1 ||
+        f->BindPairs[0].InIndex != 1 || f->BindPairs[0].OutIndex != 0)
+      return SZ_ERROR_UNSUPPORTED;
+    return SZ_OK;
+  }
+  if (f->NumCoders == 4)
+  {
+    if (IS_UNSUPPORTED_CODER(f->Coders[1]) ||
+        IS_UNSUPPORTED_CODER(f->Coders[2]) ||
+        IS_NO_BCJ2(f->Coders[3]))
+      return SZ_ERROR_UNSUPPORTED;
+    if (f->NumPackStreams != 4 ||
+        f->PackStreams[0] != 2 ||
+        f->PackStreams[1] != 6 ||
+        f->PackStreams[2] != 1 ||
+        f->PackStreams[3] != 0 ||
+        f->NumBindPairs != 3 ||
+        f->BindPairs[0].InIndex != 5 || f->BindPairs[0].OutIndex != 0 ||
+        f->BindPairs[1].InIndex != 4 || f->BindPairs[1].OutIndex != 1 ||
+        f->BindPairs[2].InIndex != 3 || f->BindPairs[2].OutIndex != 2)
+      return SZ_ERROR_UNSUPPORTED;
+    return SZ_OK;
+  }
+  return SZ_ERROR_UNSUPPORTED;
+}
+
+static
+UInt64 GetSum(const UInt64 *values, UInt32 index)
+{
+  UInt64 sum = 0;
+  UInt32 i;
+  for (i = 0; i < index; i++)
+    sum += values[i];
+  return sum;
+}
+
+static
+SRes SzDecode2(const UInt64 *packSizes, const CSzFolder *folder,
+    ILookInStream *inStream, UInt64 startPos,
+    Byte *outBuffer, SizeT outSize, ISzAlloc *allocMain,
+    Byte *tempBuf[])
+{
+  UInt32 ci;
+  SizeT tempSizes[3] = { 0, 0, 0};
+  SizeT tempSize3 = 0;
+  Byte *tempBuf3 = 0;
+
+  RINOK(CheckSupportedFolder(folder));
+
+  for (ci = 0; ci < folder->NumCoders; ci++)
+  {
+    CSzCoderInfo *coder = &folder->Coders[ci];
+
+    if (coder->MethodID == k_Copy || coder->MethodID == k_LZMA)
+    {
+      UInt32 si = 0;
+      UInt64 offset;
+      UInt64 inSize;
+      Byte *outBufCur = outBuffer;
+      SizeT outSizeCur = outSize;
+      if (folder->NumCoders == 4)
+      {
+        UInt32 indices[] = { 3, 2, 0 };
+        UInt64 unpackSize = folder->UnpackSizes[ci];
+        si = indices[ci];
+        if (ci < 2)
+        {
+          Byte *temp;
+          outSizeCur = (SizeT)unpackSize;
+          if (outSizeCur != unpackSize)
+            return SZ_ERROR_MEM;
+          temp = (Byte *)IAlloc_Alloc(allocMain, outSizeCur);
+          if (temp == 0 && outSizeCur != 0)
+            return SZ_ERROR_MEM;
+          outBufCur = tempBuf[1 - ci] = temp;
+          tempSizes[1 - ci] = outSizeCur;
+        }
+        else if (ci == 2)
+        {
+          if (unpackSize > outSize) /* check it */
+            return SZ_ERROR_PARAM;
+          tempBuf3 = outBufCur = outBuffer + (outSize - (size_t)unpackSize);
+          tempSize3 = outSizeCur = (SizeT)unpackSize;
+        }
+        else
+          return SZ_ERROR_UNSUPPORTED;
+      }
+      offset = GetSum(packSizes, si);
+      inSize = packSizes[si];
+      RINOK(LookInStream_SeekTo(inStream, startPos + offset));
+
+      if (coder->MethodID == k_Copy)
+      {
+        if (inSize != outSizeCur) /* check it */
+          return SZ_ERROR_DATA;
+        RINOK(SzDecodeCopy(inSize, inStream, outBufCur));
+      }
+      else
+      {
+        RINOK(SzDecodeLzma(coder, inSize, inStream, outBufCur, outSizeCur, allocMain));
+      }
+    }
+    else if (coder->MethodID == k_BCJ)
+    {
+      UInt32 state;
+      if (ci != 1)
+        return SZ_ERROR_UNSUPPORTED;
+      x86_Convert_Init(state);
+      x86_Convert(outBuffer, outSize, 0, &state, 0);
+    }
+    else if (coder->MethodID == k_BCJ2)
+    {
+      UInt64 offset = GetSum(packSizes, 1);
+      UInt64 s3Size = packSizes[1];
+      SRes res;
+      if (ci != 3)
+        return SZ_ERROR_UNSUPPORTED;
+      RINOK(LookInStream_SeekTo(inStream, startPos + offset));
+      tempSizes[2] = (SizeT)s3Size;
+      if (tempSizes[2] != s3Size)
+        return SZ_ERROR_MEM;
+      tempBuf[2] = (Byte *)IAlloc_Alloc(allocMain, tempSizes[2]);
+      if (tempBuf[2] == 0 && tempSizes[2] != 0)
+        return SZ_ERROR_MEM;
+      res = SzDecodeCopy(s3Size, inStream, tempBuf[2]);
+      RINOK(res)
+
+      res = Bcj2_Decode(
+          tempBuf3, tempSize3,
+          tempBuf[0], tempSizes[0],
+          tempBuf[1], tempSizes[1],
+          tempBuf[2], tempSizes[2],
+          outBuffer, outSize);
+      RINOK(res)
+    }
+    else
+      return SZ_ERROR_UNSUPPORTED;
+  }
+  return SZ_OK;
+}
+
+SRes SzDecode(const UInt64 *packSizes, const CSzFolder *folder,
+    ILookInStream *inStream, UInt64 startPos,
+    Byte *outBuffer, size_t outSize, ISzAlloc *allocMain)
+{
+  Byte *tempBuf[3] = { 0, 0, 0};
+  int i;
+  SRes res = SzDecode2(packSizes, folder, inStream, startPos,
+      outBuffer, (SizeT)outSize, allocMain, tempBuf);
+  for (i = 0; i < 3; i++)
+    IAlloc_Free(allocMain, tempBuf[i]);
+  return res;
+}

snesreader/7z_C/7zDecode.h

@@ -0,0 +1,13 @@
+/* 7zDecode.h -- Decoding from 7z folder
+2008-11-23 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_DECODE_H
+#define __7Z_DECODE_H
+
+#include "7zItem.h"
+
+SRes SzDecode(const UInt64 *packSizes, const CSzFolder *folder,
+    ILookInStream *stream, UInt64 startPos,
+    Byte *outBuffer, size_t outSize, ISzAlloc *allocMain);
+
+#endif

snesreader/7z_C/7zExtract.c

@@ -0,0 +1,93 @@
+/* 7zExtract.c -- Extracting from 7z archive
+2008-11-23 : Igor Pavlov : Public domain */
+
+#include "7zCrc.h"
+#include "7zDecode.h"
+#include "7zExtract.h"
+
+SRes SzAr_Extract(
+    const CSzArEx *p,
+    ILookInStream *inStream,
+    UInt32 fileIndex,
+    UInt32 *blockIndex,
+    Byte **outBuffer,
+    size_t *outBufferSize,
+    size_t *offset,
+    size_t *outSizeProcessed,
+    ISzAlloc *allocMain,
+    ISzAlloc *allocTemp)
+{
+  UInt32 folderIndex = p->FileIndexToFolderIndexMap[fileIndex];
+  SRes res = SZ_OK;
+  *offset = 0;
+  *outSizeProcessed = 0;
+  if (folderIndex == (UInt32)-1)
+  {
+    IAlloc_Free(allocMain, *outBuffer);
+    *blockIndex = folderIndex;
+    *outBuffer = 0;
+    *outBufferSize = 0;
+    return SZ_OK;
+  }
+
+  if (*outBuffer == 0 || *blockIndex != folderIndex)
+  {
+    CSzFolder *folder = p->db.Folders + folderIndex;
+    UInt64 unpackSizeSpec = SzFolder_GetUnpackSize(folder);
+    size_t unpackSize = (size_t)unpackSizeSpec;
+    UInt64 startOffset = SzArEx_GetFolderStreamPos(p, folderIndex, 0);
+
+    if (unpackSize != unpackSizeSpec)
+      return SZ_ERROR_MEM;
+    *blockIndex = folderIndex;
+    IAlloc_Free(allocMain, *outBuffer);
+    *outBuffer = 0;
+    
+    RINOK(LookInStream_SeekTo(inStream, startOffset));
+    
+    if (res == SZ_OK)
+    {
+      *outBufferSize = unpackSize;
+      if (unpackSize != 0)
+      {
+        *outBuffer = (Byte *)IAlloc_Alloc(allocMain, unpackSize);
+        if (*outBuffer == 0)
+          res = SZ_ERROR_MEM;
+      }
+      if (res == SZ_OK)
+      {
+        res = SzDecode(p->db.PackSizes +
+          p->FolderStartPackStreamIndex[folderIndex], folder,
+          inStream, startOffset,
+          *outBuffer, unpackSize, allocTemp);
+        if (res == SZ_OK)
+        {
+          if (folder->UnpackCRCDefined)
+          {
+            if (CrcCalc(*outBuffer, unpackSize) != folder->UnpackCRC)
+              res = SZ_ERROR_CRC;
+          }
+        }
+      }
+    }
+  }
+  if (res == SZ_OK)
+  {
+    UInt32 i;
+    CSzFileItem *fileItem = p->db.Files + fileIndex;
+    *offset = 0;
+    for (i = p->FolderStartFileIndex[folderIndex]; i < fileIndex; i++)
+      *offset += (UInt32)p->db.Files[i].Size;
+    *outSizeProcessed = (size_t)fileItem->Size;
+    if (*offset + *outSizeProcessed > *outBufferSize)
+      return SZ_ERROR_FAIL;
+    {
+      if (fileItem->FileCRCDefined)
+      {
+        if (CrcCalc(*outBuffer + *offset, *outSizeProcessed) != fileItem->FileCRC)
+          res = SZ_ERROR_CRC;
+      }
+    }
+  }
+  return res;
+}

snesreader/7z_C/7zExtract.h

@@ -0,0 +1,49 @@
+/* 7zExtract.h -- Extracting from 7z archive
+2008-11-23 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_EXTRACT_H
+#define __7Z_EXTRACT_H
+
+#include "7zIn.h"
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+/*
+  SzExtract extracts file from archive
+
+  *outBuffer must be 0 before first call for each new archive.
+
+  Extracting cache:
+    If you need to decompress more than one file, you can send
+    these values from previous call:
+      *blockIndex,
+      *outBuffer,
+      *outBufferSize
+    You can consider "*outBuffer" as cache of solid block. If your archive is solid,
+    it will increase decompression speed.
+  
+    If you use external function, you can declare these 3 cache variables
+    (blockIndex, outBuffer, outBufferSize) as static in that external function.
+    
+    Free *outBuffer and set *outBuffer to 0, if you want to flush cache.
+*/
+
+SRes SzAr_Extract(
+    const CSzArEx *db,
+    ILookInStream *inStream,
+    UInt32 fileIndex,         /* index of file */
+    UInt32 *blockIndex,       /* index of solid block */
+    Byte **outBuffer,         /* pointer to pointer to output buffer (allocated with allocMain) */
+    size_t *outBufferSize,    /* buffer size for output buffer */
+    size_t *offset,           /* offset of stream for required file in *outBuffer */
+    size_t *outSizeProcessed, /* size of file in *outBuffer */
+    ISzAlloc *allocMain,
+    ISzAlloc *allocTemp);
+
+#ifdef __cplusplus
+	}
+#endif
+
+#endif

snesreader/7z_C/7zHeader.c

@@ -0,0 +1,6 @@
+/*  7zHeader.c -- 7z Headers
+2008-10-04 : Igor Pavlov : Public domain */
+
+#include "7zHeader.h"
+
+Byte k7zSignature[k7zSignatureSize] = {'7', 'z', 0xBC, 0xAF, 0x27, 0x1C};

snesreader/7z_C/7zHeader.h

@@ -0,0 +1,57 @@
+/* 7zHeader.h -- 7z Headers
+2008-10-04 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_HEADER_H
+#define __7Z_HEADER_H
+
+#include "Types.h"
+
+#define k7zSignatureSize 6
+extern Byte k7zSignature[k7zSignatureSize];
+
+#define k7zMajorVersion 0
+
+#define k7zStartHeaderSize 0x20
+
+enum EIdEnum
+{
+  k7zIdEnd,
+    
+  k7zIdHeader,
+    
+  k7zIdArchiveProperties,
+    
+  k7zIdAdditionalStreamsInfo,
+  k7zIdMainStreamsInfo,
+  k7zIdFilesInfo,
+  
+  k7zIdPackInfo,
+  k7zIdUnpackInfo,
+  k7zIdSubStreamsInfo,
+  
+  k7zIdSize,
+  k7zIdCRC,
+  
+  k7zIdFolder,
+  
+  k7zIdCodersUnpackSize,
+  k7zIdNumUnpackStream,
+  
+  k7zIdEmptyStream,
+  k7zIdEmptyFile,
+  k7zIdAnti,
+  
+  k7zIdName,
+  k7zIdCTime,
+  k7zIdATime,
+  k7zIdMTime,
+  k7zIdWinAttributes,
+  k7zIdComment,
+  
+  k7zIdEncodedHeader,
+  
+  k7zIdStartPos,
+  k7zIdDummy
+};
+
+#endif

snesreader/7z_C/7zIn.h

@@ -0,0 +1,49 @@
+/* 7zIn.h -- 7z Input functions
+2008-11-23 : Igor Pavlov : Public domain */
+
+#ifndef __7Z_IN_H
+#define __7Z_IN_H
+
+#include "7zHeader.h"
+#include "7zItem.h"
+
+#ifdef __cplusplus
+	extern "C" {
+#endif
+
+typedef struct
+{
+  CSzAr db;
+  
+  UInt64 startPosAfterHeader;
+  UInt64 dataPos;
+
+  UInt32 *FolderStartPackStreamIndex;
+  UInt64 *PackStreamStartPositions;
+  UInt32 *FolderStartFileIndex;
+  UInt32 *FileIndexToFolderIndexMap;
+} CSzArEx;
+
+void SzArEx_Init(CSzArEx *p);
+void SzArEx_Free(CSzArEx *p, ISzAlloc *alloc);
+UInt64 SzArEx_GetFolderStreamPos(const CSzArEx *p, UInt32 folderIndex, UInt32 indexInFolder);
+int SzArEx_GetFolderFullPackSize(const CSzArEx *p, UInt32 folderIndex, UInt64 *resSize);
+
+/*
+Errors:
+SZ_ERROR_NO_ARCHIVE
+SZ_ERROR_ARCHIVE
+SZ_ERROR_UNSUPPORTED
+SZ_ERROR_MEM
+SZ_ERROR_CRC
+SZ_ERROR_INPUT_EOF
+SZ_ERROR_FAIL
+*/
+
+SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp);
+ 
+#ifdef __cplusplus
+	}
+#endif
+
+#endif