Kart-Public/tools/wadzip/wadzip.c

312 lines
7.1 KiB
C
Raw Normal View History

2014-03-15 16:59:03 +00:00
/*
* Wad compressor/decompressor by Graue <graue@oceanbase.org>
* Written January 23, 2007
*
* This file is in the public domain; use it without any restrictions.
*/
#include <stdio.h>
#include <stdlib.h>
#ifndef _MSC_VER
#include <stdint.h>
#else
typedef unsigned int uint32_t;
typedef unsigned char uint8_t;
typedef unsigned short uint16_t;
#endif
#include <errno.h>
#include <string.h>
#include "err.h"
#include "lzf.h"
#include "xm.h"
/* Note: Define WORDS_BIGENDIAN if that is the case on the target CPU. */
#define MINCOMPRESS 1024 // Don't bother compressing lumps smaller than this.
#define SWAP16(n) ((((n)&0xff)<<8) | ((n)>>8))
#define SWAP32(n) \
( \
((((n)&0xff) <<24) \
| ((((n)>>8)&0xff)<<16) \
| ((((n)>>16)&0xff)<<8) \
| ((n)>>24) \
)
#ifdef WORDS_BIGENDIAN
#define conv16le SWAP16
#define conv32le SWAP32
#else
#define conv16le(n) (n)
#define conv32le(n) (n)
#endif
#define READFUNC(name, type, conv) \
static type name(FILE *fp) \
{ \
type val; \
if (fread(&val, sizeof val, 1, fp) < 1) \
{ \
if (ferror(fp)) \
err(1, "error reading input file"); \
errx(1, "premature end of input file"); \
} \
val = conv(val); \
return val; \
}
READFUNC(read32le, uint32_t, conv32le)
#define WRITEFUNC(name, type, conv) \
static void name(FILE *fp, type val) \
{ \
val = conv(val); \
if (fwrite(&val, sizeof (type), 1, fp) < 1) \
err(1, "error writing output file"); \
}
WRITEFUNC(write32le, uint32_t, conv32le)
#define ID_IWAD 0x44415749
#define ID_PWAD 0x44415750
#define ID_ZWAD 0x4441575a // 'ZWAD' for lzf-compressed wad
typedef struct
{
char name[8];
uint32_t len;
void *data;
} lump_t;
typedef struct
{
uint32_t id;
uint32_t numlumps;
lump_t *lumps;
} wad_t;
extern char *__progname;
static void usage(void)
{
fprintf(stderr, "usage: %s [cd] infile outfile\n", __progname);
exit(EXIT_FAILURE);
}
#define fileoffset_t long
#define myseek fseek
#define mytell ftell
static void readlumpdata(lump_t *lump, uint32_t csize, int compressed, FILE *fp)
{
uint8_t *cbuf;
uint8_t *ubuf;
uint32_t usize;
unsigned int retval;
cbuf = xm(1, csize);
if (fread(cbuf, csize, 1, fp) < 1)
err(1, "cannot read lump from input file");
if (!compressed)
{
lump->len = csize;
lump->data = cbuf;
return;
}
usize = conv32le(*(uint32_t *)cbuf);
if (usize == 0)
{
lump->len = csize - 4;
lump->data = cbuf + 4; // XXX cannot be freed later
return;
}
ubuf = xm(1, usize);
retval = lzf_decompress(cbuf + 4, csize - 4, ubuf, usize);
if (retval == 0)
{
if (errno == E2BIG)
errx(1, "decompressed data bigger than advertised");
if (errno == EINVAL)
errx(1, "invalid compressed (lzf) data");
else
err(1, "unknown error from lzf");
}
else if (retval < usize)
errx(1, "decompressed data smaller than advertised");
lump->len = usize;
lump->data = ubuf;
free(cbuf);
return;
}
static wad_t *readwad(const char *fname)
{
wad_t *wad;
FILE *fp;
int inputcompressed;
fileoffset_t dirstart;
uint32_t ix;
fp = fopen(fname, "rb");
if (fp == NULL) err(1, "%s", fname);
wad = xm(sizeof *wad, 1);
// Read wad id. If it is ZWAD, prepare to read compressed lumps.
wad->id = read32le(fp);
inputcompressed = wad->id == ID_ZWAD;
// Read number of lumps, and prepare space for that many.
wad->numlumps = read32le(fp);
wad->lumps = xm(sizeof wad->lumps[0], wad->numlumps);
// Read offset to directory.
dirstart = (fileoffset_t)read32le(fp);
for (ix = 0; ix < wad->numlumps; ix++)
{
fileoffset_t lumpofs;
uint32_t lumpsize; // The compressed size, if it is compressed.
if (myseek(fp, dirstart + (16*ix), SEEK_SET) == -1)
{
err(1, "cannot seek input file to dir entry %lu",
(unsigned long)ix);
}
lumpofs = (fileoffset_t)read32le(fp);
lumpsize = read32le(fp);
if (fread(wad->lumps[ix].name, 1, 8, fp) < 8)
err(1, "cannot read lump %lu name", (unsigned long)ix);
// Don't try to seek to zero-length lumps.
// Their offset is meaningless.
if (lumpsize == 0)
{
wad->lumps[ix].len = 0;
continue;
}
if (myseek(fp, lumpofs, SEEK_SET) == -1)
err(1, "cannot seek to lump %lu", (unsigned long)ix);
readlumpdata(&wad->lumps[ix], lumpsize, inputcompressed, fp);
}
if (fclose(fp) == EOF)
warn("error closing input file %s", fname);
return wad;
}
void writewad(const wad_t *wad, const char *fname, int compress)
{
uint32_t *lumpofs; // Each lump's offset in the file.
uint32_t *disksize; // Each lump's disk size (compressed if applicable).
uint32_t dirstart;
uint32_t ix;
FILE *fp;
lumpofs = xm(sizeof lumpofs[0], wad->numlumps);
disksize = xm(sizeof disksize[0], wad->numlumps);
fp = fopen(fname, "wb");
if (fp == NULL) err(1, "%s", fname);
// Write header.
write32le(fp, compress ? ID_ZWAD : ID_PWAD);
write32le(fp, wad->numlumps);
write32le(fp, 0); // Directory table comes later.
for (ix = 0; ix < wad->numlumps; ix++)
{
uint8_t *cbuf;
uint32_t csize;
lumpofs[ix] = (uint32_t)mytell(fp);
if (!compress)
{
cbuf = wad->lumps[ix].data;
csize = wad->lumps[ix].len;
}
else
{
unsigned int retval;
csize = wad->lumps[ix].len + 4;
cbuf = xm(1, csize);
if (wad->lumps[ix].len < MINCOMPRESS
|| (retval = lzf_compress(wad->lumps[ix].data,
wad->lumps[ix].len, cbuf + 4,
csize - 5)) == 0)
{
// Store uncompressed.
memcpy(cbuf + 4, wad->lumps[ix].data,
wad->lumps[ix].len);
*(uint32_t *)cbuf = 0;
}
else
{
// Compression succeeded.
// Store uncompressed size, and set compressed
// size properly.
*(uint32_t *)cbuf =
conv32le(wad->lumps[ix].len);
csize = retval + 4;
}
}
2014-08-05 23:59:40 +00:00
if (!csize)
; // inu: 0 length markers aren't to be written
else if (fwrite(cbuf, csize, 1, fp) < 1)
2014-03-15 16:59:03 +00:00
{
err(1, "cannot write lump %lu to %s", (unsigned long)ix,
fname);
}
if (compress)
free(cbuf);
disksize[ix] = csize;
}
dirstart = (uint32_t)mytell(fp);
if (myseek(fp, 8L, SEEK_SET) == -1)
err(1, "cannot reseek %s to write directory start", fname);
write32le(fp, dirstart);
if (myseek(fp, dirstart, SEEK_SET) == -1)
err(1, "cannot reseek %s to write actual directory", fname);
for (ix = 0; ix < wad->numlumps; ix++)
{
// Write the lump's directory entry.
write32le(fp, lumpofs[ix]);
write32le(fp, disksize[ix]);
if (fwrite(wad->lumps[ix].name, 1, 8, fp) < 8)
{
err(1, "cannot write lump %lu's name",
(unsigned long)ix);
}
}
if (fclose(fp) == EOF)
warn("error closing output file %s", fname);
}
int main(int argc, char *argv[])
{
const char *infile, *outfile;
wad_t *wad;
int compress;
if (argc != 4 || strlen(argv[1]) != 1)
usage();
/* c to compress, d to decompress */
if (argv[1][0] == 'c') compress = 1;
else if (argv[1][0] == 'd') compress = 0;
else usage();
infile = argv[2];
outfile = argv[3];
wad = readwad(infile);
writewad(wad, outfile, compress);
return 0;
}