diff --git a/zsnes/src/jma/iiostrm.cpp b/zsnes/src/jma/iiostrm.cpp
index c9fec54d..621a85a4 100644
--- a/zsnes/src/jma/iiostrm.cpp
+++ b/zsnes/src/jma/iiostrm.cpp
@@ -1,4 +1,5 @@
 /*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
 Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
 Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
 
@@ -19,26 +20,114 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 #include "portable.h"
 #include "iiostrm.h"
+#include "crc32.h"
 
-HRESULT ISequentialInStream::Read(void *aData, UINT32 aSize, UINT32* aProcessedSize) {
-	if (aSize > size)
-		aSize = size;
-	*aProcessedSize = aSize;
-	memcpy(aData, data, aSize);
-	size -= aSize;
-	data += aSize;
-	return S_OK;
+HRESULT ISequentialInStream_Array::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  if (aSize > size)
+  {
+    aSize = size;
+  }  
+
+  *aProcessedSize = aSize;
+  memcpy(aData, data, aSize);
+  size -= aSize;
+  data += aSize;
+  return(S_OK);
 }
 
-HRESULT ISequentialOutStream::Write(const void *aData, UINT32 aSize, UINT32* aProcessedSize) {
-	if (aSize > size) {
-		overflow = true;
-		aSize = size;
-	}
-	*aProcessedSize = aSize;
-	memcpy(data, aData, aSize);
-	size -= aSize;
-	data += aSize;
-	total += aSize;
-	return S_OK;
+HRESULT ISequentialOutStream_Array::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  if (aSize > size)
+  {
+    overflow = true;
+    aSize = size;
+  }
+
+  *aProcessedSize = aSize;
+  memcpy(data, aData, aSize);
+  size -= aSize;
+  data += aSize;
+  total += aSize;
+  return(S_OK);
+}
+
+HRESULT ISequentialInStream_String::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  if (aSize > data.size())
+  {
+    aSize = data.size();
+  }  
+
+  *aProcessedSize = aSize;
+  memcpy(aData, data.c_str(), aSize);
+  data.erase(0, aSize);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStream_String::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  *aProcessedSize = aSize;
+  data.append((const char *)aData, aSize);
+  total += aSize;
+  return(S_OK);
+}
+
+HRESULT ISequentialInStream_Istream::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  data.read((char *)aData, aSize);
+  *aProcessedSize = data.gcount();
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStream_Ostream::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  *aProcessedSize = aSize;
+  data.write((char *)aData, aSize);
+  total += aSize;
+  return(S_OK);
+}
+
+
+
+HRESULT ISequentialInStreamCRC32_Array::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialInStream_Array::Read(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStreamCRC32_Array::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialOutStream_Array::Write(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialInStreamCRC32_String::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialInStream_String::Read(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStreamCRC32_String::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialOutStream_String::Write(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialInStreamCRC32_Istream::Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialInStream_Istream::Read(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
+}
+
+HRESULT ISequentialOutStreamCRC32_Ostream::Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize)
+{
+  ISequentialOutStream_Ostream::Write(aData, aSize, aProcessedSize);
+  crc32 = CRC32lib::CRC32((const unsigned char *)aData, *aProcessedSize, ~crc32);
+  return(S_OK);
 }
diff --git a/zsnes/src/jma/iiostrm.h b/zsnes/src/jma/iiostrm.h
index 7cb94744..7d066763 100644
--- a/zsnes/src/jma/iiostrm.h
+++ b/zsnes/src/jma/iiostrm.h
@@ -1,4 +1,5 @@
 /*
+Copyright (C) 2005 NSRT Team ( http://nsrt.edgeemu.com )
 Copyright (C) 2002 Andrea Mazzoleni ( http://advancemame.sf.net )
 Copyright (C) 2001-4 Igor Pavlov ( http://www.7-zip.org )
 
@@ -20,31 +21,161 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 #ifndef __IINOUTSTREAMS_H
 #define __IINOUTSTREAMS_H
 
+#include <string>
+#include <fstream>
+
 #include "portable.h"
 
+
 class ISequentialInStream
 {
-	const char* data;
-	unsigned size;
 public:
-	ISequentialInStream(const char* Adata, unsigned Asize) : data(Adata), size(Asize) { }
-
-	HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+  virtual HRESULT Read(void *, UINT32, UINT32 *) = 0;
 };
 
+
+class ISequentialInStream_Array : public ISequentialInStream
+{
+  const char *data;
+  unsigned int size;
+public:
+  ISequentialInStream_Array(const char *Adata, unsigned Asize) : data(Adata), size(Asize) { }
+  
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+class ISequentialInStream_String : public ISequentialInStream
+{
+  std::string& data;
+public:
+  ISequentialInStream_String(std::string& Adata) : data(Adata) { }
+  
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+class ISequentialInStream_Istream : public ISequentialInStream
+{
+  std::istream& data;
+public:
+  ISequentialInStream_Istream(std::istream& Adata) : data(Adata) { }
+  
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+
+
 class ISequentialOutStream
 {
-	char* data;
-	unsigned size;
-	bool overflow;
-	unsigned total;
 public:
-	ISequentialOutStream(char* Adata, unsigned Asize) : data(Adata), size(Asize), overflow(false), total(0) { }
+  virtual bool overflow_get() const = 0;
+  virtual unsigned int size_get() const = 0;
 
-	bool overflow_get() const { return overflow; }
-	unsigned size_get() const { return total; }
+  virtual HRESULT Write(const void *, UINT32, UINT32 *) = 0;
+};
 
-	HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+ 
+class ISequentialOutStream_Array : public ISequentialOutStream
+{
+  char *data;
+  unsigned int size;
+  bool overflow;
+  unsigned int total;
+public:
+  ISequentialOutStream_Array(char *Adata, unsigned Asize) : data(Adata), size(Asize), overflow(false), total(0) { }
+
+  bool overflow_get() const { return(overflow); }
+  unsigned int size_get() const { return(total); }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+class ISequentialOutStream_String : public ISequentialOutStream
+{
+  std::string& data;
+  unsigned int total;
+public:
+  ISequentialOutStream_String(std::string& Adata) : data(Adata), total(0) { }
+
+  bool overflow_get() const { return(false); }
+  unsigned int size_get() const { return(total); }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+
+class ISequentialOutStream_Ostream : public ISequentialOutStream
+{
+  std::ostream& data;
+  unsigned int total;
+public:
+  ISequentialOutStream_Ostream(std::ostream& Adata) : data(Adata), total(0) { }
+
+  bool overflow_get() const { return(false); }
+  unsigned int size_get() const { return(total); }
+
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+
+
+class ISequentialStreamCRC32
+{
+protected:  
+  unsigned int crc32;
+public:
+  ISequentialStreamCRC32() : crc32(0) {}
+  unsigned int crc32_get() const { return(crc32); }
+};
+
+
+class ISequentialInStreamCRC32_Array : public ISequentialInStream_Array, public ISequentialStreamCRC32
+{
+public:  
+  ISequentialInStreamCRC32_Array(const char *Adata, unsigned Asize) : ISequentialInStream_Array(Adata, Asize) { }
+  
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+class ISequentialInStreamCRC32_String : public ISequentialInStream_String, public ISequentialStreamCRC32
+{
+public:  
+  ISequentialInStreamCRC32_String(std::string& Adata) : ISequentialInStream_String(Adata) { }
+  
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+class ISequentialInStreamCRC32_Istream : public ISequentialInStream_Istream, public ISequentialStreamCRC32
+{
+public:
+  ISequentialInStreamCRC32_Istream(std::istream& Adata) : ISequentialInStream_Istream(Adata) { }
+  
+  HRESULT Read(void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+ 
+class ISequentialOutStreamCRC32_Array : public ISequentialOutStream_Array, public ISequentialStreamCRC32
+{
+public:
+  ISequentialOutStreamCRC32_Array(char *Adata, unsigned Asize) : ISequentialOutStream_Array(Adata, Asize) { }
+  
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+class ISequentialOutStreamCRC32_String : public ISequentialOutStream_String, public ISequentialStreamCRC32
+{
+public:
+  ISequentialOutStreamCRC32_String(std::string& Adata) : ISequentialOutStream_String(Adata) { }
+  
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
+};
+
+
+class ISequentialOutStreamCRC32_Ostream : public ISequentialOutStream_Ostream, public ISequentialStreamCRC32
+{
+public:
+  ISequentialOutStreamCRC32_Ostream(std::ostream& Adata) : ISequentialOutStream_Ostream(Adata) { }
+  
+  HRESULT Write(const void *aData, UINT32 aSize, UINT32 *aProcessedSize);
 };
 
 #endif