Update to ZDoom r1476:

- Moved weapon slot initialization into APlayerPawn::PostBeginPlay() so that
  they can be initialized when players respawn in multiplayer.
- Added a Check for the Vavoom namespace to the UDMF parser. Functionally
  it's 100% identical with ZDoom's own but needs to be checked for in
  case Vavoom compatible UDMF maps are released.
- Added an SDL output plugin, so FMOD can produce sound using SDL's audio
  support instead of its own OSS/ALSA/ESD support. This is selectable by
  setting snd_output to "sdl".
- Fixed: On Linux systems with ALSA but no OSS support, trying to start
  the sound system with snd_output "default" would fail instead of trying
  to use ALSA.
- Added sdl_nokeyrepeat to disable key repeating in the menus and console
  on Linux.
- Added support for zip/pk3 files with LZMA and bzip2 compression to ZDoom.
- Added more output to zipdir and a -q option to turn it off.
- Added -u option to zipdir to only recompress those files in a zip that have
  changed. 
- Added -d and -f options to zipdir. -d forces deflate compression, and -f
  forces a write of the zip, even if it's newer than all the files it contains.

git-svn-id: http://mancubus.net/svn/hosted/gzdoom/trunk@307 b0f79afe-0144-0410-b225-9a4edf0717df

src/files.cpp

@@ -266,6 +266,205 @@ void FileReaderZ::FillBuffer ()
 	Stream.avail_in = numread;
 }
 
+//==========================================================================
+//
+// FileReaderZ
+//
+// The bzip2 wrapper
+// reads data from a libbzip2 compressed stream
+//
+//==========================================================================
+
+FileReaderBZ2::FileReaderBZ2 (FileReader &file)
+: File(file), SawEOF(false)
+{
+	int err;
+
+	FillBuffer ();
+
+	Stream.bzalloc = NULL;
+	Stream.bzfree = NULL;
+	Stream.opaque = NULL;
+
+	err = BZ2_bzDecompressInit(&Stream, 0, 0);
+
+	if (err != BZ_OK)
+	{
+		I_Error ("FileReaderBZ2: bzDecompressInit failed: %d\n", err);
+	}
+}
+
+FileReaderBZ2::~FileReaderBZ2 ()
+{
+	BZ2_bzDecompressEnd (&Stream);
+}
+
+long FileReaderBZ2::Read (void *buffer, long len)
+{
+	int err;
+
+	Stream.next_out = (char *)buffer;
+	Stream.avail_out = len;
+
+	do
+	{
+		err = BZ2_bzDecompress(&Stream);
+		if (Stream.avail_in == 0 && !SawEOF)
+		{
+			FillBuffer ();
+		}
+	} while (err == BZ_OK && Stream.avail_out != 0);
+
+	if (err != BZ_OK && err != BZ_STREAM_END)
+	{
+		I_Error ("Corrupt bzip2 stream");
+	}
+
+	if (Stream.avail_out != 0)
+	{
+		I_Error ("Ran out of data in bzip2 stream");
+	}
+
+	return len - Stream.avail_out;
+}
+
+void FileReaderBZ2::FillBuffer ()
+{
+	long numread = File.Read(InBuff, BUFF_SIZE);
+
+	if (numread < BUFF_SIZE)
+	{
+		SawEOF = true;
+	}
+	Stream.next_in = (char *)InBuff;
+	Stream.avail_in = numread;
+}
+
+//==========================================================================
+//
+// bz_internal_error
+//
+// libbzip2 wants this, since we build it with BZ_NO_STDIO set.
+//
+//==========================================================================
+
+extern "C" void bz_internal_error (int errcode)
+{
+	I_FatalError("libbzip2: internal error number %d\n", errcode);
+}
+
+//==========================================================================
+//
+// FileReaderLZMA
+//
+// The lzma wrapper
+// reads data from a LZMA compressed stream
+//
+//==========================================================================
+
+static void *SzAlloc(void *p, size_t size) { p = p; return malloc(size); }
+static void SzFree(void *p, void *address) { p = p; free(address); }
+static ISzAlloc g_Alloc = { SzAlloc, SzFree };
+
+FileReaderLZMA::FileReaderLZMA (FileReader &file, size_t uncompressed_size, bool zip)
+: File(file), SawEOF(false)
+{
+	BYTE header[4 + LZMA_PROPS_SIZE];
+	int err;
+
+	assert(zip == true);
+
+	Size = uncompressed_size;
+	OutProcessed = 0;
+
+	// Read zip LZMA properties header
+	if (File.Read(header, sizeof(header)) < (long)sizeof(header))
+	{
+		I_Error("FileReaderLZMA: File too shart\n");
+	}
+	if (header[2] + header[3] * 256 != LZMA_PROPS_SIZE)
+	{
+		I_Error("FileReaderLZMA: LZMA props size is %d (expected %d)\n",
+			header[2] + header[3] * 256, LZMA_PROPS_SIZE);
+	}
+
+	FillBuffer();
+
+	LzmaDec_Construct(&Stream);
+	err = LzmaDec_Allocate(&Stream, header + 4, LZMA_PROPS_SIZE, &g_Alloc);
+
+	if (err != SZ_OK)
+	{
+		I_Error("FileReaderLZMA: LzmaDec_Allocate failed: %d\n", err);
+	}
+
+	LzmaDec_Init(&Stream);
+}
+
+FileReaderLZMA::~FileReaderLZMA ()
+{
+	LzmaDec_Free(&Stream, &g_Alloc);
+}
+
+long FileReaderLZMA::Read (void *buffer, long len)
+{
+	int err;
+	Byte *next_out = (Byte *)buffer;
+
+	do
+	{
+		ELzmaFinishMode finish_mode = LZMA_FINISH_ANY;
+		ELzmaStatus status;
+		size_t out_processed = len;
+		size_t in_processed = InSize;
+
+		err = LzmaDec_DecodeToBuf(&Stream, next_out, &out_processed, InBuff + InPos, &in_processed, finish_mode, &status);
+		InPos += in_processed;
+		InSize -= in_processed;
+		next_out += out_processed;
+		len = (long)(len - out_processed);
+		if (err != SZ_OK)
+		{
+			I_Error ("Corrupt LZMA stream");
+		}
+		if (in_processed == 0 && out_processed == 0)
+		{
+			if (status != LZMA_STATUS_FINISHED_WITH_MARK)
+			{
+				I_Error ("Corrupt LZMA stream");
+			}
+		}
+		if (InSize == 0 && !SawEOF)
+		{
+			FillBuffer ();
+		}
+	} while (err == SZ_OK && len != 0);
+
+	if (err != Z_OK && err != Z_STREAM_END)
+	{
+		I_Error ("Corrupt LZMA stream");
+	}
+
+	if (len != 0)
+	{
+		I_Error ("Ran out of data in LZMA stream");
+	}
+
+	return (long)(next_out - (Byte *)buffer);
+}
+
+void FileReaderLZMA::FillBuffer ()
+{
+	long numread = File.Read(InBuff, BUFF_SIZE);
+
+	if (numread < BUFF_SIZE)
+	{
+		SawEOF = true;
+	}
+	InPos = 0;
+	InSize = numread;
+}
+
 //==========================================================================
 //
 // MemoryReader
@@ -320,4 +519,3 @@ char *MemoryReader::Gets(char *strbuf, int len)
 {
 	return GetsFromBuffer(bufptr, strbuf, len);
 }
-