SC1 unpacking tools
git-svn-id: svn://svn.code.sf.net/p/sc2/code/trunk@2767 8092fc87-c524-0410-9efc-e669fe64eaf9
This commit is contained in:
Meep-Eep
@@ -0,0 +1,9 @@
|
||||
TARGET := decomp
|
||||
CFILES := ../../shared/util.c huff.c decomp.c lztfb.c
|
||||
HFILES := ../../shared/cbytesex.h ../../shared/util.h dostypes.h huff.h lztfb.h getbit.h
|
||||
CFLAGS := -std=c99
|
||||
DEBUG := 1
|
||||
#ERROR := 1
|
||||
|
||||
include ../../shared/Makefile.default
|
||||
|
||||
@@ -0,0 +1,156 @@
|
||||
/*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include "huff.h"
|
||||
#include "lztfb.h"
|
||||
#include "../../shared/util.h"
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
#include <fcntl.h>
|
||||
#include <getopt.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
|
||||
|
||||
struct options {
|
||||
char *inFile;
|
||||
char *outFile;
|
||||
bool testOnly;
|
||||
};
|
||||
|
||||
void usage(FILE *out);
|
||||
void parse_arguments(int argc, char *argv[], struct options *opts);
|
||||
bool testCompressed(const char *fileName);
|
||||
|
||||
int
|
||||
main(int argc, char *argv[]) {
|
||||
void *buf;
|
||||
size_t size;
|
||||
bool compressed;
|
||||
FILE *out;
|
||||
|
||||
struct options opts;
|
||||
parse_arguments(argc, argv, &opts);
|
||||
|
||||
if (opts.testOnly) {
|
||||
return testCompressed(opts.inFile) ? EXIT_SUCCESS : EXIT_FAILURE;
|
||||
} else if (opts.outFile == NULL) {
|
||||
logError(false, "Either -o or -t needs to be specified.\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
if (mmapOpen(opts.inFile, O_RDONLY, &buf, &size) == -1)
|
||||
fatal(true, "mmapOpen() failed.\n");
|
||||
|
||||
if (((char *) buf)[0] == 6 && (((char *) buf)[1] & ~0x6) == 0) {
|
||||
compressed = true;
|
||||
} else {
|
||||
compressed = false;
|
||||
if (getU32BE((char *) buf + 2) != size - 6)
|
||||
fatal(false, "File '%s' is not in a recognised format.\n",
|
||||
opts.inFile);
|
||||
}
|
||||
|
||||
out = fopen(opts.outFile, "w");
|
||||
if (out == NULL)
|
||||
fatal(true, "fopen() failed.\n");
|
||||
|
||||
if (compressed) {
|
||||
LZTFB *lztfb = LZTFB_new(buf, size);
|
||||
if (lztfb == NULL)
|
||||
fatal(false, "LZTFB_new() failed.\n");
|
||||
|
||||
if (LZTFB_output(lztfb, out) == -1)
|
||||
fatal(true, "LZTFB_output() failed.\n");
|
||||
|
||||
LZTFB_delete(lztfb);
|
||||
} else {
|
||||
if (fwrite((char *) buf + 6, 1, size - 6, out) != size - 6)
|
||||
fatal(true, "fwrite() failed.\n");
|
||||
}
|
||||
|
||||
(void) fclose(out);
|
||||
munmap(buf, size);
|
||||
|
||||
(void) argc;
|
||||
(void) argv;
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
void
|
||||
usage(FILE *out) {
|
||||
fprintf(out, "Syntax:\n"
|
||||
"decomp -o <outfile> <infile>\n"
|
||||
"decomp -t <infile>\n"
|
||||
"\t-o decompress to outfile\n"
|
||||
"\t-t only test whether the file is compressed.\n"
|
||||
"\t returns 0 if compressed, and 1 if not compressed\n");
|
||||
}
|
||||
|
||||
void
|
||||
parse_arguments(int argc, char *argv[], struct options *opts) {
|
||||
char ch;
|
||||
|
||||
memset(opts, '\0', sizeof (struct options));
|
||||
while (1) {
|
||||
ch = getopt(argc, argv, "ho:t");
|
||||
if (ch == -1)
|
||||
break;
|
||||
switch(ch) {
|
||||
case 'o':
|
||||
opts->outFile = optarg;
|
||||
break;
|
||||
case '?':
|
||||
case 'h':
|
||||
usage(stdout);
|
||||
exit(EXIT_SUCCESS);
|
||||
case 't':
|
||||
opts->testOnly = true;
|
||||
break;
|
||||
default:
|
||||
usage(stderr);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
if (argc != 1) {
|
||||
usage(stderr);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
opts->inFile = argv[0];
|
||||
}
|
||||
|
||||
bool
|
||||
testCompressed(const char *fileName) {
|
||||
FILE *file;
|
||||
|
||||
file = fopen(fileName, "rb");
|
||||
if (file == NULL)
|
||||
return false;
|
||||
|
||||
uint8_t buf[6];
|
||||
if (fread(buf, 1, 6, file) != 6) {
|
||||
fclose(file);
|
||||
return false;
|
||||
}
|
||||
fclose(file);
|
||||
|
||||
return buf[0] == 6 && (buf[1] & ~0x6) == 0;
|
||||
}
|
||||
|
||||
|
||||
Executable
+8
@@ -0,0 +1,8 @@
|
||||
#!/bin/sh
|
||||
|
||||
DECOMP=./decomp
|
||||
|
||||
for FILE in *[23459a]; do
|
||||
$DECOMP -o "$FILE.out" "$FILE"
|
||||
done
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
/*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef _DOSTYPES_H
|
||||
#define _DOSTYPES_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
typedef uint8_t BYTE;
|
||||
typedef int8_t SBYTE;
|
||||
typedef uint16_t WORD;
|
||||
typedef int16_t SWORD;
|
||||
typedef uint32_t DWORD;
|
||||
typedef int32_t SDWORD;
|
||||
|
||||
#endif /* _DOSTYPES_H */
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef _GETBIT_H
|
||||
#define _GETBIT_H
|
||||
|
||||
static inline WORD
|
||||
haveBit(BitStreamContext *bsc) {
|
||||
return BSC_haveBit_OPAB(bsc);
|
||||
}
|
||||
|
||||
static inline WORD
|
||||
getBit(BitStreamContext *bsc) {
|
||||
if (haveBit(bsc))
|
||||
return BSC_getBit_OPAB(bsc);
|
||||
|
||||
bsc->eof = true;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline WORD
|
||||
haveBits(BitStreamContext *bsc, BYTE count) {
|
||||
return BSC_haveBits_OPAB(bsc, count);
|
||||
}
|
||||
|
||||
// On EOF, this outputs garbage; this is how the original TFB code worked.
|
||||
static inline WORD
|
||||
getBits(BitStreamContext *bsc, BYTE count) {
|
||||
if (haveBits(bsc, count))
|
||||
return BSC_getBits_OPAB(bsc, count);
|
||||
|
||||
bsc->eof = true;
|
||||
return BSC_getBits_OPAB(bsc, BSC_bitsLeft_OPAB(bsc));
|
||||
}
|
||||
|
||||
#endif /* _GETBIT_H */
|
||||
|
||||
@@ -0,0 +1,344 @@
|
||||
// Reverse engineered from the Star Control executable.
|
||||
|
||||
#include "huff.h"
|
||||
#include "../../shared/cbytesex.h"
|
||||
#include "getbit.h"
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static bool Huff_compareCodes(const Huff_Code *srcCodePtr,
|
||||
const Huff_Code *destCodePtr);
|
||||
static void Huff_sortAndStuff(int flag, Huff_Context *ctx);
|
||||
static void Huff_sub_22334(Huff_Context *ctx);
|
||||
static void Huff_reverseCodeBits(Huff_Context *ctx);
|
||||
static bool Huff_readTable(Huff_Context *ctx);
|
||||
static bool Huff_lookupCodeLarge(Huff_Context *ctx, DWORD *result);
|
||||
static bool Huff_lookupCodeSmall(Huff_Context *ctx, DWORD *result);
|
||||
|
||||
Huff_Context *
|
||||
Huff_new(BitStreamContext *bsc, WORD codeCount) {
|
||||
Huff_Context *result = malloc(sizeof (Huff_Context));
|
||||
|
||||
result->codeCount = codeCount;
|
||||
result->bsc = bsc;
|
||||
|
||||
if (!Huff_readTable(result))
|
||||
goto err;
|
||||
Huff_sortAndStuff(0, result);
|
||||
Huff_sub_22334(result);
|
||||
Huff_reverseCodeBits(result);
|
||||
Huff_sortAndStuff(1, result);
|
||||
|
||||
return result;
|
||||
|
||||
err:
|
||||
free (result);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
Huff_delete(Huff_Context *ctx) {
|
||||
free(ctx);
|
||||
}
|
||||
|
||||
// Returns true if we need to swap.
|
||||
static bool
|
||||
Huff_compareCodes(const Huff_Code *srcCodePtr, const Huff_Code *destCodePtr) {
|
||||
// 2203:016a
|
||||
|
||||
if (destCodePtr->len < srcCodePtr->len)
|
||||
return true;
|
||||
|
||||
if (destCodePtr->len > srcCodePtr->len)
|
||||
return false;
|
||||
|
||||
if (destCodePtr->field_0 < srcCodePtr->field_0)
|
||||
return true;
|
||||
|
||||
if (destCodePtr->field_0 > srcCodePtr->field_0)
|
||||
return false;
|
||||
|
||||
if (destCodePtr->value < srcCodePtr->value)
|
||||
return true;
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
static void
|
||||
Huff_sortAndStuff(int flag, Huff_Context *ctx) {
|
||||
// 2203:00c6
|
||||
if (flag != 0 && ctx->maxCodeLen <= 8) {
|
||||
// ctx->codes is reordered so that
|
||||
// ctx->codes[i] == ctx->codes[i]->field_0
|
||||
|
||||
// 2203:00d3
|
||||
ctx->u.topCodeIndexLen = ctx->codes[0].len;
|
||||
|
||||
WORD codeI = 0;
|
||||
if (ctx->codeCount == 0)
|
||||
return;
|
||||
|
||||
// 2203:00e9
|
||||
Huff_Code *codePtr = &ctx->codes[0];
|
||||
|
||||
do {
|
||||
// 2203:011a
|
||||
// Put *codePtr in its place by swapping it with the Huff_Code
|
||||
// structure where it needs to go.
|
||||
// We continue doing this as long as the new value of *codePtr
|
||||
// is not yet in its place.
|
||||
while (codePtr->field_0 != codeI &&
|
||||
/* 2203:00ed */ codePtr->len != 0) {
|
||||
// 2203:00f3
|
||||
// Swap ctx->codes[codePtr->field_0] and *codePtr
|
||||
Huff_Code *otherCode = &ctx->codes[codePtr->field_0];
|
||||
Huff_Code tempCode = *codePtr;
|
||||
*codePtr = *otherCode;
|
||||
*otherCode = tempCode;
|
||||
// 2203:011a
|
||||
}
|
||||
|
||||
// 2203:0121
|
||||
codePtr++;
|
||||
codeI++;
|
||||
} while (codeI < ctx->codeCount);
|
||||
|
||||
return;
|
||||
} else {
|
||||
// Sorting the array of codes (using comb sort).
|
||||
// The codes with the smaller code length are put first.
|
||||
|
||||
// 2203:0139
|
||||
WORD si = ctx->codeCount / 2;
|
||||
|
||||
for (;;) {
|
||||
// 2203:0143
|
||||
bool noSwapThisRound = true;
|
||||
|
||||
if (si >= ctx->codeCount)
|
||||
goto loc_22200;
|
||||
|
||||
// 2203:0158
|
||||
Huff_Code *srcCodePtr = &ctx->codes[0];
|
||||
Huff_Code *destCodePtr = &ctx->codes[si];
|
||||
|
||||
WORD cx = 0;
|
||||
do {
|
||||
// 2203:016a
|
||||
if (Huff_compareCodes(srcCodePtr, destCodePtr)) {
|
||||
// 2203:018e
|
||||
Huff_Code tempCode = *srcCodePtr;
|
||||
*srcCodePtr = *destCodePtr;
|
||||
*destCodePtr = tempCode;
|
||||
|
||||
noSwapThisRound = false;
|
||||
}
|
||||
|
||||
// 2203:01b3
|
||||
srcCodePtr++;
|
||||
destCodePtr++;
|
||||
cx++;
|
||||
} while (cx < ctx->codeCount - si);
|
||||
|
||||
loc_22200:
|
||||
// 2203:01d0
|
||||
if (!noSwapThisRound)
|
||||
continue;
|
||||
|
||||
si /= 2;
|
||||
if (si <= 0)
|
||||
break;
|
||||
}
|
||||
|
||||
// 2203:01e2
|
||||
if (flag == 0)
|
||||
return;
|
||||
|
||||
si = 0;
|
||||
for (WORD cx = 0; cx < ctx->codeCount; cx++) {
|
||||
// Keep si from previous round.
|
||||
while (si < ctx->codes[cx].len) {
|
||||
// 2203:0200
|
||||
ctx->u.codeIndices[si] = cx;
|
||||
si++;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Pre: codes are sorted on code length (smallest first).
|
||||
static void
|
||||
Huff_sub_22334(Huff_Context *ctx) {
|
||||
// 2203:030f
|
||||
WORD dx = 0;
|
||||
WORD var_6 = 0;
|
||||
WORD prevCodeLen = 0;
|
||||
|
||||
WORD codeI = ctx->codeCount;
|
||||
Huff_Code *codePtr = &ctx->codes[codeI - 1];
|
||||
|
||||
while (codeI != 0) {
|
||||
// 2203:032f
|
||||
dx += var_6;
|
||||
if (codePtr->len != prevCodeLen) {
|
||||
// 2203:033d
|
||||
prevCodeLen = codePtr->len;
|
||||
var_6 = 1 << (16 - codePtr->len);
|
||||
}
|
||||
|
||||
codePtr->field_0 = dx;
|
||||
|
||||
codePtr--;
|
||||
codeI--;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
Huff_reverseCodeBits(Huff_Context *ctx) {
|
||||
Huff_Code *codePtr = &ctx->codes[0];
|
||||
|
||||
for (WORD codeI = ctx->codeCount; codeI != 0; codeI--) {
|
||||
// 2203:0376
|
||||
WORD wordToReverse = codePtr->field_0;
|
||||
WORD rightBit = 1;
|
||||
WORD leftBit = 0x8000;
|
||||
WORD reversedWord = 0;
|
||||
|
||||
BYTE bitI = 16;
|
||||
do {
|
||||
// 2203:0390
|
||||
if (wordToReverse & rightBit)
|
||||
reversedWord |= leftBit;
|
||||
|
||||
leftBit >>= 1;
|
||||
rightBit <<= 1;
|
||||
bitI--;
|
||||
} while (bitI != 0);
|
||||
|
||||
codePtr->field_0 = reversedWord;
|
||||
codePtr++;
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
Huff_readTable(Huff_Context *ctx) {
|
||||
// 2203:022b
|
||||
if (!haveBits(ctx->bsc, 8))
|
||||
return false;
|
||||
WORD lengthCount = getBits(ctx->bsc, 8) + 1;
|
||||
// Number of lengths for codes in this table.
|
||||
|
||||
// 2203:025d
|
||||
WORD index = 0;
|
||||
ctx->maxCodeLen = 0;
|
||||
|
||||
// 2203:026a
|
||||
while (lengthCount != 0) {
|
||||
// 2203:0271
|
||||
if (index >= 0x100 || !haveBits(ctx->bsc, 8))
|
||||
return false;
|
||||
WORD dx = getBits(ctx->bsc, 8);
|
||||
|
||||
WORD thisCodeLenCount = highU4(dx) + 1;
|
||||
// Number of codes with this length
|
||||
WORD codeLen = lowU4(dx) + 1;
|
||||
|
||||
// 2203:02af (changed order; no reason for this to be in the while
|
||||
// loop)
|
||||
if (codeLen > ctx->maxCodeLen) {
|
||||
// 2203:02b9
|
||||
ctx->maxCodeLen = codeLen;
|
||||
}
|
||||
|
||||
// 2203:02ab
|
||||
// Prepare 'thisCodeLenCount' codes with the specified code length.
|
||||
while (thisCodeLenCount != 0) {
|
||||
Huff_Code *codePtr = &ctx->codes[index];
|
||||
codePtr->len = codeLen;
|
||||
codePtr->value = index;
|
||||
codePtr->field_0 = 0;
|
||||
|
||||
index++;
|
||||
thisCodeLenCount--;
|
||||
};
|
||||
|
||||
// 2203:02e1
|
||||
lengthCount--;
|
||||
}
|
||||
|
||||
// 2203: 02e6
|
||||
if (ctx->maxCodeLen <= 8) {
|
||||
ctx->lookupCodeFunc = Huff_lookupCodeSmall;
|
||||
} else
|
||||
ctx->lookupCodeFunc = Huff_lookupCodeLarge;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
// Huffman decoder for codes of arbitrary length.
|
||||
static bool
|
||||
Huff_lookupCodeLarge(Huff_Context *ctx, DWORD *result) {
|
||||
// 2203:03f2
|
||||
Huff_Code *codePtr = &ctx->codes[0];
|
||||
|
||||
// 2203:03f8
|
||||
WORD si = getBits(ctx->bsc, codePtr->len);
|
||||
BYTE ch = codePtr->len;
|
||||
BYTE cl;
|
||||
|
||||
// 2203:0429
|
||||
while (codePtr->field_0 != si) {
|
||||
if (codePtr->field_0 < si) {
|
||||
// 2203:042f
|
||||
codePtr++;
|
||||
cl = codePtr->len - ch;
|
||||
if (cl == 0)
|
||||
continue;
|
||||
} else {
|
||||
// 2203:0459
|
||||
WORD ax = (WORD) ctx->u.codeIndices[ch];
|
||||
codePtr = &ctx->codes[ax];
|
||||
cl = codePtr->len - ch;
|
||||
}
|
||||
|
||||
// 2203:043d and 2203:0479
|
||||
WORD ax = getBits(ctx->bsc, cl);
|
||||
|
||||
// 2203:049cd
|
||||
si |= (ax << ch);
|
||||
ch += cl;
|
||||
}
|
||||
|
||||
*result = codePtr->value;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Table-based huffman decoding.
|
||||
// Code lengths are no longer than 8 bits.
|
||||
// ctx->codes[]->value contains the value produced.
|
||||
static bool
|
||||
Huff_lookupCodeSmall(Huff_Context *ctx, DWORD *result) {
|
||||
// 2203:04b4
|
||||
WORD codeI = getBits(ctx->bsc, ctx->u.topCodeIndexLen);
|
||||
WORD haveCodeBits = ctx->u.topCodeIndexLen;
|
||||
|
||||
// 2203:04f1
|
||||
Huff_Code *codePtr;
|
||||
for (;;) {
|
||||
codePtr = &ctx->codes[codeI];
|
||||
if (haveCodeBits == codePtr->len)
|
||||
break;
|
||||
|
||||
WORD ax = getBit(ctx->bsc);
|
||||
|
||||
// 2203:051c
|
||||
codeI |= (ax << haveCodeBits);
|
||||
haveCodeBits++;
|
||||
}
|
||||
|
||||
*result = codePtr->value;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
// Reverse engineered from the Star Control executable.
|
||||
|
||||
#ifndef _HUFF_H
|
||||
#define _HUFF_H
|
||||
|
||||
typedef struct Huff_Code Huff_Code;
|
||||
typedef struct Huff_Context Huff_Context;
|
||||
|
||||
#include "dostypes.h"
|
||||
#include "../../shared/cbytesex.h"
|
||||
|
||||
|
||||
struct Huff_Code {
|
||||
WORD field_0;
|
||||
BYTE value;
|
||||
BYTE len;
|
||||
};
|
||||
|
||||
struct Huff_Context {
|
||||
Huff_Code codes[0x100];
|
||||
WORD codeCount;
|
||||
WORD maxCodeLen;
|
||||
bool (*lookupCodeFunc)(Huff_Context *ctx, DWORD *result);
|
||||
|
||||
BitStreamContext *bsc;
|
||||
|
||||
union {
|
||||
BYTE topCodeIndexLen;
|
||||
// Number of bits in the index of the top code.
|
||||
BYTE codeIndices[16];
|
||||
// Index into 'codes' to the first code with some length.
|
||||
} u;
|
||||
};
|
||||
|
||||
Huff_Context *Huff_new(BitStreamContext *bsc, WORD codeCount);
|
||||
void Huff_delete(Huff_Context *ctx);
|
||||
|
||||
static inline bool
|
||||
Huff_getCode(Huff_Context *ctx, DWORD *result) {
|
||||
return ctx->lookupCodeFunc(ctx, result);
|
||||
}
|
||||
|
||||
#endif /* _HUFF_H */
|
||||
|
||||
@@ -0,0 +1,336 @@
|
||||
// Reverse engineered from the Star Control executable.
|
||||
|
||||
#include "lztfb.h"
|
||||
|
||||
#include "../../shared/cbytesex.h"
|
||||
#include "../../shared/util.h"
|
||||
#include "getbit.h"
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
static bool LZTFB_processMore(LZTFB *lztfb);
|
||||
|
||||
|
||||
LZTFB *
|
||||
LZTFB_new(const char *buf, size_t len) {
|
||||
LZTFB *result = NULL;
|
||||
|
||||
if (len < 6)
|
||||
goto err;
|
||||
|
||||
if (buf[0] != 0x06) {
|
||||
// Not a compressed file.
|
||||
goto err;
|
||||
}
|
||||
|
||||
result = malloc(sizeof (LZTFB));
|
||||
result->huffTable[0] = NULL;
|
||||
result->huffTable[1] = NULL;
|
||||
result->huffTable[2] = NULL;
|
||||
|
||||
result->state = 0;
|
||||
result->stateData.offset = 0;
|
||||
result->stateData.count = 0;
|
||||
|
||||
result->compressedSize = len;
|
||||
result->uncompressedSize = getU32BE(buf + 2);
|
||||
|
||||
if ((buf[1] & 2) != 0) {
|
||||
result->table2Shift = 7;
|
||||
} else
|
||||
result->table2Shift = 6;
|
||||
|
||||
BSC_init(&result->bsc, buf + 6, len);
|
||||
|
||||
if ((buf[1] & 4) != 0) {
|
||||
// Literal bytes are huffman encoded.
|
||||
result->lengthBias = 3;
|
||||
result->literalsEncoded = true;
|
||||
} else {
|
||||
// Literal bytes are read directly from the input.
|
||||
result->lengthBias = 2;
|
||||
result->literalsEncoded = false;
|
||||
result->huffTable[0] = NULL;
|
||||
}
|
||||
|
||||
memset(result->buf, '\0', LZTFB_BUF_SIZE);
|
||||
result->bufPtr = result->buf;
|
||||
result->bufFill = 0;
|
||||
result->lastBufFill = 0;
|
||||
|
||||
return result;
|
||||
err:
|
||||
if (result != NULL)
|
||||
LZTFB_delete(result);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void
|
||||
LZTFB_delete(LZTFB *lztfb) {
|
||||
for (int tableI = 0; tableI < 3; tableI++) {
|
||||
if (lztfb->huffTable[0] != NULL)
|
||||
Huff_delete(lztfb->huffTable[0]);
|
||||
}
|
||||
|
||||
free(lztfb);
|
||||
}
|
||||
|
||||
int
|
||||
LZTFB_output(LZTFB *lztfb, FILE *out) {
|
||||
// 21e0:00aa
|
||||
size_t toOutput = lztfb->uncompressedSize;
|
||||
|
||||
while (toOutput > 0) {
|
||||
lztfb->bufPtr = lztfb->buf;
|
||||
lztfb->bufFill = 0;
|
||||
|
||||
if (!LZTFB_processMore(lztfb)) {
|
||||
logError(false, "LZTFB_processMore failed.\n");
|
||||
errno = EIO;
|
||||
return -1;
|
||||
}
|
||||
lztfb->lastBufFill = lztfb->bufFill;
|
||||
|
||||
size_t toWrite = lztfb->bufFill;
|
||||
if (toWrite > toOutput)
|
||||
toWrite = toOutput;
|
||||
size_t written = fwrite(lztfb->buf, 1, toWrite, out);
|
||||
if (written != toWrite) {
|
||||
assert(ferror(out));
|
||||
logError(true, "fwrite() failed.\n");
|
||||
return -1;
|
||||
}
|
||||
toOutput -= written;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Memcopy from left to right. (memcpy doesn't guarantee this, and memmove
|
||||
// does it differently)
|
||||
static inline void
|
||||
memcpyLtr(void *dest, void *src, size_t size) {
|
||||
while (size--) {
|
||||
*((uint8_t *) dest) = *((uint8_t *) src);
|
||||
src = ((uint8_t *) src) + 1;
|
||||
dest = ((uint8_t *) dest) + 1;
|
||||
}
|
||||
}
|
||||
|
||||
static bool
|
||||
LZTFB_processMore(LZTFB *lztfb) {
|
||||
// 2203:0555
|
||||
int32_t offset = lztfb->stateData.offset;
|
||||
uint32_t count = lztfb->stateData.count;
|
||||
lztfb->stateData.count = 0;
|
||||
uint8_t table2Shift = lztfb->table2Shift;
|
||||
uint8_t lengthBias = lztfb->lengthBias;
|
||||
|
||||
if (lztfb->state == 0) {
|
||||
if (lztfb->literalsEncoded) {
|
||||
lztfb->huffTable[0] = Huff_new(&lztfb->bsc, 0x100);
|
||||
if (lztfb->huffTable[0] == NULL)
|
||||
goto err;
|
||||
}
|
||||
|
||||
lztfb->huffTable[1] = Huff_new(&lztfb->bsc, 0x40);
|
||||
if (lztfb->huffTable[1] == NULL)
|
||||
goto err;
|
||||
|
||||
lztfb->huffTable[2] = Huff_new(&lztfb->bsc, 0x40);
|
||||
if (lztfb->huffTable[2] == NULL)
|
||||
goto err;
|
||||
|
||||
goto state1;
|
||||
}
|
||||
|
||||
if (lztfb->state == 1) {
|
||||
state1:
|
||||
// State 1: read more data and decide what to do.
|
||||
|
||||
// The original code flagged EOF when it needed to read a new
|
||||
// byte, and this wasn't possible. But while EOF it would
|
||||
// still return undefined bytes.
|
||||
// Because there may be a couple of bits left at the end of the
|
||||
// stream (as the stream contains bytes) we can't know whether
|
||||
// the end of the stream has been reached as long as we still
|
||||
// have a couple of bits left. So we handle EOF the same way.
|
||||
if (lztfb->bsc.eof)
|
||||
return true;
|
||||
|
||||
int bit = getBit(&lztfb->bsc);
|
||||
if (bit != 0) {
|
||||
// Literal byte.
|
||||
if (lztfb->huffTable[0] == NULL) {
|
||||
// Literal byte is read directly from the input.
|
||||
*lztfb->bufPtr = getBits(&lztfb->bsc, 8);
|
||||
} else {
|
||||
// Literal byte is Huffman-encoded.
|
||||
uint32_t dummy;
|
||||
if (!Huff_getCode(lztfb->huffTable[0], &dummy))
|
||||
goto err;
|
||||
*lztfb->bufPtr = (uint8_t) dummy;
|
||||
}
|
||||
|
||||
lztfb->bufPtr++;
|
||||
lztfb->bufFill++;
|
||||
if (lztfb->bufFill == LZTFB_BUF_SIZE) {
|
||||
lztfb->state = 1;
|
||||
return true;
|
||||
}
|
||||
goto state1;
|
||||
}
|
||||
|
||||
offset = getBits(&lztfb->bsc, table2Shift);
|
||||
|
||||
uint32_t ax;
|
||||
if (!Huff_getCode(lztfb->huffTable[2], &ax))
|
||||
goto err;
|
||||
ax = (ax << table2Shift) | offset;
|
||||
offset = lztfb->lastBufFill + lztfb->bufFill - ax;
|
||||
// This looks like a bug; if lztfb->bufFill !=
|
||||
// LZTFB_BUF_SIZE, the offset is wrong.
|
||||
|
||||
if (!Huff_getCode(lztfb->huffTable[1], &ax))
|
||||
goto err;
|
||||
ax += lengthBias;
|
||||
count = ax;
|
||||
|
||||
if (ax == lengthBias + 0x3fU) {
|
||||
// 6 bits was not enough; read 8 more.
|
||||
count += getBits(&lztfb->bsc, 8);
|
||||
}
|
||||
|
||||
offset--;
|
||||
if (offset < 0) {
|
||||
goto state2;
|
||||
} else
|
||||
goto state3;
|
||||
}
|
||||
|
||||
if (lztfb->state == 2) {
|
||||
state2:
|
||||
// State 2: repeat '\0' a number of times.
|
||||
// offset == -repeatCount
|
||||
|
||||
// 2203:0588
|
||||
// Never more than count bytes.
|
||||
if (offset < (int32_t) -count)
|
||||
offset = -count;
|
||||
// This means count will become 0 in the next line.
|
||||
|
||||
count += offset;
|
||||
// offset is negative; count gets smaller
|
||||
|
||||
do {
|
||||
uint32_t repeatCount = -offset;
|
||||
if (repeatCount + lztfb->bufFill <= LZTFB_BUF_SIZE) {
|
||||
// Enough room for repeatCount more characters.
|
||||
memset(lztfb->bufPtr, '\0', repeatCount);
|
||||
lztfb->bufFill += repeatCount;
|
||||
lztfb->bufPtr += repeatCount;
|
||||
offset = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
lztfb->stateData.count = repeatCount -
|
||||
(LZTFB_BUF_SIZE - lztfb->bufFill);
|
||||
offset += (LZTFB_BUF_SIZE - lztfb->bufFill);
|
||||
// offset was negative; it now contains the negation of
|
||||
// the number of bytes that still fit in the buffer.
|
||||
} while (offset != 0);
|
||||
|
||||
if (lztfb->bufFill != LZTFB_BUF_SIZE) {
|
||||
if (count == 0)
|
||||
goto state1;
|
||||
|
||||
// count bytes will be copied from the start of the buffer.
|
||||
// I don't get it.
|
||||
goto state3;
|
||||
}
|
||||
// Buffer is full
|
||||
|
||||
if (count != 0 || lztfb->stateData.count != 0) {
|
||||
lztfb->stateData.offset = -lztfb->stateData.count;
|
||||
lztfb->stateData.count += count;
|
||||
lztfb->state = 2;
|
||||
// Next time, continue where we left off.
|
||||
return true;
|
||||
}
|
||||
|
||||
lztfb->state = 1;
|
||||
// Next time, start by reading more data.
|
||||
return true;
|
||||
}
|
||||
|
||||
state3:
|
||||
// State 3: Backreference to an earlier piece of data
|
||||
// offset is the offset of the earlier data
|
||||
// count is the length.
|
||||
|
||||
offset &= LZTFB_BUF_SIZE - 1;
|
||||
// offset %= LZTFB_BUF_SIZE
|
||||
|
||||
for (;;) {
|
||||
if (count + lztfb->bufFill > LZTFB_BUF_SIZE) {
|
||||
// There's no room in the buffer for this many bytes. Adjust
|
||||
// the size, and save the rest for later.
|
||||
|
||||
lztfb->stateData.count =
|
||||
count - (LZTFB_BUF_SIZE - lztfb->bufFill);
|
||||
count = LZTFB_BUF_SIZE - lztfb->bufFill;
|
||||
if (count == 0) {
|
||||
// Buffer was completely full.
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (count + offset <= LZTFB_BUF_SIZE) {
|
||||
// All the data that is referenced comes from the previous
|
||||
// call to this function.
|
||||
// Copy lztfb[offset..(offset + count)] to bufPtr.
|
||||
memcpyLtr(lztfb->bufPtr, &lztfb->buf[offset], count);
|
||||
lztfb->bufPtr += count;
|
||||
lztfb->bufFill += count;
|
||||
break;
|
||||
}
|
||||
|
||||
// Copy lztfb[offset..] to bufPtr. The rest of the data to be copied
|
||||
// comes from the data we wrote this call.
|
||||
memcpyLtr(lztfb->bufPtr, &lztfb->buf[offset],
|
||||
LZTFB_BUF_SIZE - offset);
|
||||
lztfb->bufPtr += LZTFB_BUF_SIZE - offset;
|
||||
lztfb->bufFill += LZTFB_BUF_SIZE - offset;
|
||||
count -= LZTFB_BUF_SIZE - offset;
|
||||
offset = 0;
|
||||
}
|
||||
// count contains the number of bytes written since offset was last
|
||||
// adjusted.
|
||||
|
||||
if (lztfb->bufFill != LZTFB_BUF_SIZE)
|
||||
goto state1;
|
||||
|
||||
if (lztfb->stateData.count == 0) {
|
||||
lztfb->state = 1;
|
||||
// Next time, start by reading new data.
|
||||
return true;
|
||||
} else {
|
||||
lztfb->stateData.offset = offset + count;
|
||||
// offset was not yet adjusted with count after the last write
|
||||
lztfb->state = 3;
|
||||
// Next time, continue where we left off.
|
||||
return true;
|
||||
}
|
||||
|
||||
err:
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
// Reverse engineered from the Star Control executable.
|
||||
|
||||
#ifndef _LZTFB
|
||||
#define _LZTFB
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
typedef struct LZTFB LZTFB;
|
||||
|
||||
#include "../../shared/cbytesex.h"
|
||||
#include "huff.h"
|
||||
|
||||
#define LZTFB_BUF_SIZE 0x2000
|
||||
|
||||
struct LZTFB {
|
||||
uint8_t buf[LZTFB_BUF_SIZE];
|
||||
uint8_t *bufPtr;
|
||||
uint32_t bufFill;
|
||||
uint32_t lastBufFill;
|
||||
|
||||
BitStreamContext bsc;
|
||||
|
||||
bool literalsEncoded;
|
||||
Huff_Context *huffTable[3];
|
||||
int state;
|
||||
struct {
|
||||
int32_t offset;
|
||||
uint32_t count;
|
||||
} stateData;
|
||||
|
||||
size_t compressedSize;
|
||||
size_t uncompressedSize;
|
||||
|
||||
uint8_t table2Shift;
|
||||
uint8_t lengthBias;
|
||||
};
|
||||
|
||||
LZTFB *LZTFB_new(const char *buf, size_t len);
|
||||
int LZTFB_output(LZTFB *lztfb, FILE *out);
|
||||
void LZTFB_delete(LZTFB *lztfb);
|
||||
|
||||
#endif /* _LZTFB */
|
||||
|
||||
@@ -0,0 +1,10 @@
|
||||
TARGET := unianm
|
||||
CFILES := unianm.c ../../shared/util.c
|
||||
HFILES := unianm.h ../../shared/cbytesex.h ../../shared/util.h
|
||||
CPPFLAGS := `pkg-config --cflags libpng`
|
||||
LDFLAGS := `pkg-config --libs libpng`
|
||||
DEBUG := 1
|
||||
#ERROR := 1
|
||||
|
||||
include ../../shared/Makefile.default
|
||||
|
||||
@@ -0,0 +1,507 @@
|
||||
/*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <fcntl.h>
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <getopt.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <png.h>
|
||||
|
||||
#include "unianm.h"
|
||||
#include "../../shared/cbytesex.h"
|
||||
#include "../../shared/util.h"
|
||||
|
||||
struct options {
|
||||
const char *inFile;
|
||||
const char *outDir;
|
||||
FILE *out;
|
||||
int resType;
|
||||
bool verbose;
|
||||
const char *paletteFile;
|
||||
int paletteNr;
|
||||
};
|
||||
|
||||
void usage(FILE *out);
|
||||
void parse_arguments(int argc, char *argv[], struct options *opts);
|
||||
void verbose(const struct options *opts, const char *format, ...)
|
||||
__attribute__((format(printf, 2, 3)));
|
||||
bool processFile(const struct options *opts, uint8_t *buf, size_t size,
|
||||
Anim **retAnim);
|
||||
MasterPaletteColor *readPalette(struct options *opts);
|
||||
bool writePngFile(const struct options *opts, const char *fileName,
|
||||
const Anim *anim, const Frame *frame,
|
||||
const MasterPaletteColor *palette);
|
||||
int getDigitCount(uint32_t num);
|
||||
bool outputFrames(struct options *opts, Anim *anim,
|
||||
const MasterPaletteColor *masterPalette);
|
||||
|
||||
|
||||
int
|
||||
main(int argc, char *argv[]) {
|
||||
void *buf = NULL;
|
||||
size_t size = 0;
|
||||
char *outDirBuf = NULL;
|
||||
uint8_t *paletteBuf = NULL;
|
||||
|
||||
struct options opts;
|
||||
parse_arguments(argc, argv, &opts);
|
||||
|
||||
if (opts.outDir != NULL && opts.paletteFile == NULL) {
|
||||
logError(false, "Need to specify a palette file.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (opts.outDir == NULL && opts.paletteFile != NULL) {
|
||||
fprintf(stderr, "Warning: -p is meaningless without -o.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (mmapOpen(opts.inFile, O_RDONLY, &buf, &size) == -1)
|
||||
fatal(true, "mmapOpen() failed.\n");
|
||||
|
||||
if (size < 8 || memcmp(buf, "IANM", 4) != 0) {
|
||||
logError(false, "File '%s' is not an ianm file.\n",
|
||||
opts.inFile);
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (opts.outDir != NULL) {
|
||||
size_t outDirLen = strlen(opts.outDir);
|
||||
if (outDirLen == 0) {
|
||||
logError(false, "Invalid output directory.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
// Add a terminating '/', if necessary.
|
||||
if (opts.outDir[outDirLen - 1] != '/') {
|
||||
outDirBuf = malloc(outDirLen + 2);
|
||||
memcpy(outDirBuf, opts.outDir, outDirLen);
|
||||
outDirBuf[outDirLen] = '/';
|
||||
outDirBuf[outDirLen + 1] = '\0';
|
||||
opts.outDir = outDirBuf;
|
||||
}
|
||||
|
||||
if (access(opts.outDir, W_OK) != 0) {
|
||||
logError(true, "Cannot write to output path.\n");
|
||||
goto err;
|
||||
}
|
||||
}
|
||||
|
||||
Anim *anim;
|
||||
if (!processFile(&opts, (uint8_t *) buf, size, &anim))
|
||||
goto err;
|
||||
|
||||
if (opts.outDir != NULL) {
|
||||
MasterPaletteColor *palette = readPalette(&opts);
|
||||
if (palette == NULL) {
|
||||
logError(false, "Failed to read palette.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
outputFrames(&opts, anim, palette);
|
||||
}
|
||||
|
||||
munmap(buf, size);
|
||||
|
||||
(void) argc;
|
||||
(void) argv;
|
||||
return EXIT_SUCCESS;
|
||||
|
||||
err:
|
||||
if (paletteBuf != NULL)
|
||||
free(paletteBuf);
|
||||
if (outDirBuf != NULL)
|
||||
free(outDirBuf);
|
||||
if (buf != NULL)
|
||||
munmap(buf, size);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
void
|
||||
usage(FILE *out) {
|
||||
fprintf(out, "Syntax:\t"
|
||||
"unianm [-v] [-c <n>] -p <palette> -t <n> -o <outdir> <infile>\n"
|
||||
"unianm [-v] [-c <n>] -t <n> <infile>\n"
|
||||
"\t-c specifies the palette to use (0, 1, or 2 (default))\n"
|
||||
"\t-p specifies the file to load the palette from\n"
|
||||
"\t-t specifies the resource type (2, 3, 4, or 5)\n"
|
||||
"\t (ignored for now)\n"
|
||||
"\t-v verbose\n");
|
||||
}
|
||||
|
||||
void
|
||||
parse_arguments(int argc, char *argv[], struct options *opts) {
|
||||
char ch;
|
||||
|
||||
memset(opts, '\0', sizeof (struct options));
|
||||
opts->out = stdout;
|
||||
opts->resType = 2;
|
||||
opts->paletteNr = 2;
|
||||
while (1) {
|
||||
ch = getopt(argc, argv, "c:ho:p:t:v");
|
||||
if (ch == -1)
|
||||
break;
|
||||
switch(ch) {
|
||||
case 'o':
|
||||
opts->outDir = optarg;
|
||||
break;
|
||||
case '?':
|
||||
case 'h':
|
||||
usage(stdout);
|
||||
exit(EXIT_SUCCESS);
|
||||
case 'c':
|
||||
if (optarg[0] < '0' || optarg[0] > 2 || optarg[1] != '\0') {
|
||||
logError(false, "Invalid argument to '-p'\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
opts->paletteNr = optarg[0] - '\0';
|
||||
break;
|
||||
case 'p':
|
||||
opts->paletteFile = optarg;
|
||||
break;
|
||||
case 't':
|
||||
opts->resType = atoi(optarg);
|
||||
if (opts->resType < 2 || opts->resType > 5) {
|
||||
logError(false, "Invalid argument to '-t'\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
break;
|
||||
case 'v':
|
||||
opts->verbose = true;
|
||||
break;
|
||||
default:
|
||||
usage(stderr);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
}
|
||||
argc -= optind;
|
||||
argv += optind;
|
||||
if (argc != 1) {
|
||||
usage(stderr);
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
opts->inFile = argv[0];
|
||||
}
|
||||
|
||||
void
|
||||
verbose(const struct options *opts, const char *format, ...) {
|
||||
if (!opts->verbose)
|
||||
return;
|
||||
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
vfprintf(opts->out, format, args);
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
// Pre: size >= 8
|
||||
bool
|
||||
processFile(const struct options *opts, uint8_t *buf, size_t bufLen,
|
||||
Anim **retAnim) {
|
||||
assert(bufLen >= 8);
|
||||
uint8_t *end = buf + bufLen;
|
||||
uint8_t *bufPtr = buf + 8;
|
||||
|
||||
Anim *anim = malloc(sizeof (Anim));
|
||||
verbose(opts, "0x00000000 \"IANM\"\n");
|
||||
|
||||
anim->frameCount = getU16BE(buf + 4);
|
||||
verbose(opts, "0x00000004 Number of frames: %d\n", anim->frameCount);
|
||||
anim->bpp = getU16BE(buf + 6) & 0xff;
|
||||
verbose(opts, "0x00000006 Bits per pixel: %d\n", anim->bpp);
|
||||
|
||||
anim->frames = malloc(anim->frameCount * sizeof (Frame));
|
||||
|
||||
for (uint16_t frameI = 0; frameI < anim->frameCount; frameI++) {
|
||||
if (bufPtr + 4 > end)
|
||||
goto fileTooSmall;
|
||||
|
||||
Frame *frame = &anim->frames[frameI];
|
||||
frame->width = getU16BE(bufPtr);
|
||||
frame->height = getU16BE(bufPtr + 2);
|
||||
verbose(opts, "0x%08x Frame %2d: %3d x %3d pixels\n",
|
||||
bufPtr - buf, frameI, frame->width, frame->height);
|
||||
bufPtr += 4;
|
||||
}
|
||||
|
||||
for (uint16_t frameI = 0; frameI < anim->frameCount; frameI++) {
|
||||
Frame *frame = &anim->frames[frameI];
|
||||
|
||||
if (bufPtr + 6 > end)
|
||||
goto fileTooSmall;
|
||||
|
||||
verbose(opts, "0x%08x Frame %d:\n",
|
||||
bufPtr - buf, frameI);
|
||||
frame->hotX = getS16BE(bufPtr);
|
||||
frame->hotY = getS16BE(bufPtr + 2);
|
||||
verbose(opts, "0x%08x Hotspot: (%3d, %3d)\n", bufPtr - buf,
|
||||
frame->hotX, frame->hotY);
|
||||
bufPtr += 4;
|
||||
frame->hasPalette = getU8(bufPtr) != 0;
|
||||
verbose(opts, "0x%08x %s (0x%02x)\n", bufPtr - buf,
|
||||
frame->hasPalette ? "paletted" : "not paletted",
|
||||
getU8(bufPtr));
|
||||
bufPtr++;
|
||||
frame->transIndex = getU8(bufPtr) & 0x0f;
|
||||
verbose(opts, "0x%08x Transparent palette index: 0x%02x\n",
|
||||
bufPtr - buf, frame->transIndex);
|
||||
bufPtr++;
|
||||
|
||||
if (frame->hasPalette) {
|
||||
if (bufPtr + 0x30 > end)
|
||||
goto fileTooSmall;
|
||||
for (int paletteI = 0; paletteI < 3; paletteI++) {
|
||||
frame->palettes[paletteI] = bufPtr;
|
||||
verbose(opts, "0x%08x Palette %d:", bufPtr - buf,
|
||||
paletteI);
|
||||
for (int i = 0; i < 0x10; i++)
|
||||
verbose(opts, " %02x", bufPtr[i]);
|
||||
verbose(opts, "\n");
|
||||
bufPtr += 0x10;
|
||||
}
|
||||
} else {
|
||||
// No palette with this frame. Copy from the previous frame,
|
||||
// if there is one.
|
||||
if (frameI == 0) {
|
||||
for (int paletteI = 0; paletteI < 3; paletteI++)
|
||||
frame->palettes[paletteI] = NULL;
|
||||
} else {
|
||||
Frame *lastFrame = &anim->frames[frameI - 1];
|
||||
for (int paletteI = 0; paletteI < 3; paletteI++)
|
||||
frame->palettes[paletteI] =
|
||||
lastFrame->palettes[paletteI];
|
||||
frame->hasPalette = lastFrame->hasPalette;
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t bitDepth = 8 / anim->bpp;
|
||||
frame->bytesPerLine = ((frame->width + (bitDepth - 1)) / bitDepth);
|
||||
frame->pixelDataSize = frame->bytesPerLine * frame->height;
|
||||
frame->pixelData = bufPtr;
|
||||
|
||||
if (bufPtr + frame->pixelDataSize > end)
|
||||
goto fileTooSmall;
|
||||
verbose(opts, "0x%08x Pixel data: %d bytes\n", bufPtr - buf,
|
||||
frame->pixelDataSize);
|
||||
bufPtr += frame->pixelDataSize;
|
||||
}
|
||||
|
||||
if ((size_t) (bufPtr - buf) != bufLen) {
|
||||
fprintf(stderr, "\nWarning: Extra data at the end of the file:\n"
|
||||
"\tdata length: %d bytes\n\tfile length: %d bytes\n",
|
||||
bufPtr - buf, bufLen);
|
||||
}
|
||||
|
||||
*retAnim = anim;
|
||||
return true;
|
||||
|
||||
fileTooSmall:
|
||||
logError(false, "\nInput file is too small.\n");
|
||||
free(anim->frames);
|
||||
free(anim);
|
||||
return false;
|
||||
}
|
||||
|
||||
MasterPaletteColor *
|
||||
readPalette(struct options *opts) {
|
||||
FILE *file = NULL;
|
||||
uint32_t *buf = malloc(0x300);
|
||||
|
||||
file = fopen(opts->paletteFile, "rb");
|
||||
if (file == NULL) {
|
||||
logError(true, "Could not open palette file.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (fread(buf, 1, 0x300, file) != 0x300) {
|
||||
logError(ferror(file), "Could not read palette file.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
fclose(file);
|
||||
return (MasterPaletteColor *) buf;
|
||||
|
||||
err:
|
||||
if (file != NULL)
|
||||
fclose(file);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
bool
|
||||
writePngFile(const struct options *opts, const char *fileName,
|
||||
const Anim *anim, const Frame *frame,
|
||||
const MasterPaletteColor *masterPalette) {
|
||||
FILE *file = NULL;
|
||||
|
||||
file = fopen(fileName, "wb");
|
||||
if (file == NULL) {
|
||||
logError(true, "Could not open file '%s' for writing.\n", fileName);
|
||||
return false;
|
||||
}
|
||||
|
||||
png_structp png_ptr;
|
||||
png_infop info_ptr;
|
||||
|
||||
png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING,
|
||||
(png_voidp) NULL /* user_error_ptr */,
|
||||
NULL /* user_error_fn */, NULL /* user_warning_fn */);
|
||||
if (!png_ptr) {
|
||||
fprintf(stderr, "png_create_write_struct failed.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
info_ptr = png_create_info_struct(png_ptr);
|
||||
if (!info_ptr) {
|
||||
png_destroy_write_struct(&png_ptr, (png_infopp) NULL);
|
||||
fprintf(stderr, "png_create_info_struct failed.\n");
|
||||
goto err;
|
||||
}
|
||||
|
||||
if (setjmp(png_jmpbuf(png_ptr))) {
|
||||
fprintf(stderr, "png error.\n");
|
||||
png_destroy_write_struct(&png_ptr, &info_ptr);
|
||||
goto err;
|
||||
}
|
||||
|
||||
png_init_io(png_ptr, file);
|
||||
png_set_IHDR(png_ptr, info_ptr, frame->width, frame->height,
|
||||
anim->bpp /* bit_depth per channel */, PNG_COLOR_TYPE_PALETTE,
|
||||
PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_DEFAULT,
|
||||
PNG_FILTER_TYPE_DEFAULT);
|
||||
|
||||
png_set_compression_level(png_ptr, 9);
|
||||
|
||||
png_set_oFFs(png_ptr, info_ptr, -frame->hotX, -frame->hotY,
|
||||
PNG_OFFSET_PIXEL);
|
||||
|
||||
png_color_8 sig_bit;
|
||||
sig_bit.red = 8;
|
||||
sig_bit.green = 8;
|
||||
sig_bit.blue = 8;
|
||||
png_set_sBIT(png_ptr, info_ptr, &sig_bit);
|
||||
|
||||
png_color pngPalette[16];
|
||||
if (frame->hasPalette) {
|
||||
uint8_t *palette = frame->palettes[opts->paletteNr];
|
||||
for (int i = 0; i < 16; i++) {
|
||||
uint8_t entry = palette[i];
|
||||
pngPalette[i].red = masterPalette[entry].red;
|
||||
pngPalette[i].green = masterPalette[entry].green;
|
||||
pngPalette[i].blue = masterPalette[entry].blue;
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < 16; i++) {
|
||||
pngPalette[i].red = masterPalette[i].red;
|
||||
pngPalette[i].green = masterPalette[i].green;
|
||||
pngPalette[i].blue = masterPalette[i].blue;
|
||||
}
|
||||
}
|
||||
png_set_PLTE(png_ptr, info_ptr, pngPalette, 16);
|
||||
|
||||
{
|
||||
// Generate transparency chunk
|
||||
// for indexed PNGs, tRNS chunk contains an array of alpha values
|
||||
// corresponding to palette entries
|
||||
png_byte trans[0x100];
|
||||
// set all palette alpha values to 0xff (fully opaque) initially
|
||||
memset(trans, 0xff, 0x100 * sizeof (png_byte));
|
||||
if (frame->transIndex < 0x10)
|
||||
trans[frame->transIndex] = 0;
|
||||
// the only one
|
||||
// only need to write out upto and including transparentPixel
|
||||
png_set_tRNS(png_ptr, info_ptr, trans, frame->transIndex + 1, NULL);
|
||||
}
|
||||
|
||||
png_write_info(png_ptr, info_ptr);
|
||||
|
||||
{
|
||||
uint8_t *linePtr = frame->pixelData;
|
||||
for (uint32_t lineI = 0; lineI < frame->height; lineI++) {
|
||||
png_write_row(png_ptr, (png_byte *) linePtr);
|
||||
linePtr += frame->bytesPerLine;
|
||||
}
|
||||
}
|
||||
|
||||
png_write_end(png_ptr, info_ptr);
|
||||
png_destroy_write_struct(&png_ptr, &info_ptr);
|
||||
|
||||
fclose(file);
|
||||
return true;
|
||||
|
||||
err:
|
||||
if (file != NULL)
|
||||
fclose(file);
|
||||
return false;
|
||||
}
|
||||
|
||||
int
|
||||
getDigitCount(uint32_t num) {
|
||||
if (num == 0)
|
||||
return 1;
|
||||
|
||||
int result = 0;
|
||||
while (num > 0) {
|
||||
num /= 10;
|
||||
result++;
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Pre: opts.outDir already has a terminating '/'.
|
||||
bool
|
||||
outputFrames(struct options *opts, Anim *anim,
|
||||
const MasterPaletteColor *palette) {
|
||||
if (anim->frameCount == 0) {
|
||||
fprintf(stderr, "Warning: no frames in file '%s'.\n",
|
||||
opts->inFile);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Get just the last component of opts->inFile.
|
||||
const char *inFileName = strrchr(opts->inFile, '/');
|
||||
if (inFileName == NULL) {
|
||||
inFileName = opts->inFile;
|
||||
} else
|
||||
inFileName++;
|
||||
|
||||
size_t outDirLen = strlen(opts->outDir);
|
||||
size_t inFileLen = strlen(inFileName);
|
||||
size_t maxPathLen = outDirLen + inFileLen + sizeof ".65535.png";
|
||||
char path[maxPathLen];
|
||||
|
||||
char *pathPtr = path +
|
||||
sprintf(path, "%s%s.", opts->outDir, inFileName);
|
||||
int digitCount = getDigitCount(anim->frameCount - 1);
|
||||
|
||||
for (uint16_t frameI = 0; frameI < anim->frameCount; frameI++) {
|
||||
Frame *frame = &anim->frames[frameI];
|
||||
|
||||
sprintf(pathPtr, "%0*d.png", digitCount, frameI);
|
||||
|
||||
if (!writePngFile(opts, path, anim, frame, palette))
|
||||
logError(false, "Writing file '%s' failed.\n", path);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,50 @@
|
||||
/*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef _UNIANM_H
|
||||
#define _UNIANM_H
|
||||
|
||||
typedef struct Frame Frame;
|
||||
typedef struct Anim Anim;
|
||||
typedef struct MasterPaletteColor MasterPaletteColor;
|
||||
|
||||
struct Frame {
|
||||
uint16_t width;
|
||||
uint16_t height;
|
||||
int16_t hotX;
|
||||
int16_t hotY;
|
||||
bool hasPalette;
|
||||
uint8_t transIndex;
|
||||
uint8_t *palettes[3];
|
||||
uint32_t bytesPerLine;
|
||||
uint32_t pixelDataSize;
|
||||
uint8_t *pixelData;
|
||||
};
|
||||
|
||||
struct Anim {
|
||||
uint16_t frameCount;
|
||||
uint8_t bpp;
|
||||
struct Frame *frames;
|
||||
};
|
||||
|
||||
struct MasterPaletteColor {
|
||||
uint8_t red;
|
||||
uint8_t green;
|
||||
uint8_t blue;
|
||||
} __attribute__((packed));
|
||||
|
||||
#endif /* _UNIANM_H */
|
||||
|
||||
Executable
+64
@@ -0,0 +1,64 @@
|
||||
#!/bin/sh
|
||||
|
||||
DECOMP=/home/svdb/cvs/sc2/tools/sc1-decomp/decomp
|
||||
UNIANM=/home/svdb/cvs/sc2/tools/sc1-ianm/unianm
|
||||
|
||||
usage() {
|
||||
echo "Syntax: unanim.sh <outdir> <infile>"
|
||||
}
|
||||
|
||||
if [ $# -lt 1 ]; then
|
||||
usage >&2
|
||||
exit 0
|
||||
fi
|
||||
|
||||
processFile() {
|
||||
local INPATH INDIR INNAME OUTDIR TMPFILE
|
||||
|
||||
INPATH=$1
|
||||
if [ "x$INPATH" = "x" ]; then
|
||||
INDIR=""
|
||||
else
|
||||
INDIR=${INPATH%%/*}
|
||||
fi
|
||||
INNAME=${INPATH##*/}
|
||||
OUTDIR=${2%/}/$INNAME
|
||||
TMPFILE=${2%/}/$INNAME.tmp
|
||||
|
||||
case "$INNAME" in
|
||||
*02)
|
||||
TYPE=2
|
||||
;;
|
||||
*03)
|
||||
TYPE=3
|
||||
;;
|
||||
*04)
|
||||
TYPE=4
|
||||
;;
|
||||
*05)
|
||||
TYPE=5
|
||||
;;
|
||||
*)
|
||||
echo "Skipping file '$INNAME' -- not of a recognised graphics type."
|
||||
return 1
|
||||
esac
|
||||
|
||||
mkdir -- "$OUTDIR"
|
||||
OUTDIR=$OUTDIR/
|
||||
|
||||
"$DECOMP" -o "$TMPFILE" -- "$INPATH"
|
||||
"$UNIANM" -o "$OUTDIR" -t "$TYPE" -p 00200008 -- "$TMPFILE"
|
||||
|
||||
rm -f -- "$TMPFILE"
|
||||
}
|
||||
|
||||
OUTDIR=$1
|
||||
shift
|
||||
while [ "$#" -gt 0 ]; do
|
||||
FILE=$1
|
||||
processFile "$FILE" "$OUTDIR"
|
||||
shift
|
||||
done
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user