}
void
-configLoadObjmap (Bool ps3)
+configLoadObjmap (uint8_t ps3)
{
char from[30] = "objattribdef-psp.ini";
}
void
-configLoadAnimmap (Bool ps3)
+configLoadAnimmap (uint8_t ps3)
{
char from[30] = "animattribdef-psp.ini";
void configLoadTagmap (void);
void configLoadMiscmap (void);
-void configLoadObjmap (Bool ps3);
-void configLoadAnimmap (Bool ps3);
+void configLoadObjmap (uint8_t ps3);
+void configLoadAnimmap (uint8_t ps3);
#endif
#include "rlzpack.h"
#include "7z/7z.h"
-uint
-zlib_compress (void *src, uint srcLen, void *dest, uint destLen, int level,
+uint32_t
+zlib_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int level,
int strat)
{
if (strat == Z_USE_7Z) {
unsigned int outSize = destLen - 6; // = 2 for sig + 4 for checksum
unsigned char *destPtr = (unsigned char *) dest;
- *(uint16 *) destPtr = 0xDA78; // zlib signature
+ *(uint16_t *) destPtr = 0xDA78; // zlib signature
destPtr += 2;
int passes = 1, fastbytes = 64;
uLong adler = adler32 (adler32 (0L, Z_NULL, 0), (Bytef *) src, srcLen);
#define ENDIAN_SWAP_32(x) (((x) & 0xFF) << 24 | ((x) & 0xFF00) << 8 | ((x) & 0xFF0000) >> 8 | ((x) & 0xFF000000) >> 24)
- *(uint32 *) (destPtr + outSize) = ENDIAN_SWAP_32 (adler);
+ *(uint32_t *) (destPtr + outSize) = ENDIAN_SWAP_32 (adler);
return outSize + 6;
} else {
return ret;
}
-uint
-zlib_unpacked_size (void *src, uint srcLen)
+uint32_t
+zlib_unpacked_size (void *src, uint32_t srcLen)
{
z_stream s;
if (inflateInit (&s) != Z_OK)
return 0xFFFFFFFF;
- uint size = 0;
+ uint32_t size = 0;
int ret;
while ((ret = inflate (&s, Z_NO_FLUSH)) == Z_OK) {
return size;
}
-uint
-rlz_compress (void *src, uint srcLen, void *dest, uint destLen, int mode)
+uint32_t
+rlz_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int mode)
{
if (mode == -1) {
// theme creator compatible mode
}
}
-Bool
+uint8_t
file_exists (char *fn)
{
// our deetection routine is weird - just tries to open the file
return FALSE;
}
-uint
+uint32_t
filesize (const char *fn)
{
FILE *fp = fopen (fn, "rb");
if (!fp)
return 0;
fseek (fp, 0, SEEK_END);
- uint f = ftell (fp);
+ uint32_t f = ftell (fp);
fclose (fp);
}
// finds the smallest prime number which is >= in
-uint
-find_larger_prime (uint in)
+uint32_t
+find_larger_prime (uint32_t in)
{
if (in <= 2)
return 2;
}
}
-Bool
-is_prime (uint in)
+uint8_t
+is_prime (uint32_t in)
{
if (in < 12) { // need this buffer as "lim" (below) may
// underflow
if ((in ^ 1) & 1)
return FALSE;
- uint i;
- uint lim = (uint) floor (sqrt ((float) in));
+ uint32_t i;
+ uint32_t lim = (uint32_t) floor (sqrt ((float) in));
for (i = 3; i <= lim; i += 2)
if (in % i == 0)
#define APPXMLVER 1.10f
#define APPVER 1.11f
-typedef unsigned int uint; // since "unsigned int" is a pain in the @$$ to
- // type
-
-typedef int Bool;
#ifndef TRUE
-#define TRUE (Bool)1
+#define TRUE (uint8_t)1
#endif
#ifndef FALSE
-#define FALSE (Bool)0
+#define FALSE (uint8_t)0
#endif
#define ENDIAN_SWAP_16(x) (((x) & 0xFF) << 8 | ((x) & 0xFF00) >> 8)
#include <stdio.h>
-extern Bool quietMode;
+extern uint8_t quietMode;
#define info(...) if(!quietMode) { fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n"); }
#define error(...) { fprintf(stderr, "Error: "); fprintf(stderr, __VA_ARGS__); fprintf(stderr, "\n"); fflush(stderr); }
// #define ALIGN_TO_4(n) (((n) + 3) >>2 <<2) // problem: upper 2 bits gets
// wiped too
-typedef uint8_t uint8;
-typedef int8_t int8;
-typedef uint16_t uint16;
-typedef int16_t int16;
-typedef uint32_t uint32;
-typedef int32_t int32;
-#define UTF8_BOM ((uint32) 0xBFBBEF)
-#define UTF16_BOM ((uint16) 0xFEFF)
-#define UTF32_BOM ((uint32) 0x0000FEFF)
+#define UTF8_BOM ((uint32_t) 0xBFBBEF)
+#define UTF16_BOM ((uint16_t) 0xFEFF)
+#define UTF32_BOM ((uint32_t) 0x0000FEFF)
#define PACK_STRUCT(nam, struc) typedef struct struc __attribute__ ((packed)) nam
-uint zlib_compress (void *src, uint srcLen, void *dest, uint destLen, int level,
+uint32_t zlib_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int level,
int strat);
int zlib_uncompress (void *dest, unsigned int destLen, const void *src,
unsigned int srcLen);
-uint zlib_unpacked_size (void *src, uint srcLen);
-uint rlz_compress (void *src, uint srcLen, void *dest, uint destLen, int mode);
-Bool file_exists (char *fn);
+uint32_t zlib_unpacked_size (void *src, uint32_t srcLen);
+uint32_t rlz_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int mode);
+uint8_t file_exists (char *fn);
-uint filesize (const char *fn);
+uint32_t filesize (const char *fn);
-uint find_larger_prime (uint in);
-Bool is_prime (uint in);
+uint32_t find_larger_prime (uint32_t in);
+uint8_t is_prime (uint32_t in);
void get_temp_fname (char *out, const char *ext);
// 0x1F object type only found in PS3 RCOs and may not be valid for PSP!!!
int *RCO_OBJ_EXTRA_LEN = NULL;
-uint RCO_OBJ_EXTRA_LEN_NUM;
+uint32_t RCO_OBJ_EXTRA_LEN_NUM;
// this doesn't include position info
RcoObjMap RCO_OBJ_EXTRA_NAMES = NULL;
RcoObjTypes RCO_OBJ_EXTRA_TYPES = NULL;
int *RCO_ANIM_EXTRA_LEN = NULL;
-uint RCO_ANIM_EXTRA_LEN_NUM;
+uint32_t RCO_ANIM_EXTRA_LEN_NUM;
-const Bool RCO_ANIM_EXTRA_REFS[] =
+const uint8_t RCO_ANIM_EXTRA_REFS[] =
{ FALSE, FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, TRUE, FALSE, FALSE,
TRUE
};
RcoTagMap RCOXML_TABLE_TAGS = NULL;
-uint RCOXML_TABLE_TAGS_NUM;
+uint32_t RCOXML_TABLE_TAGS_NUM;
RcoTableMap RCOXML_TABLE_NAMES = NULL;
int main_vsmxdec (void);
int main_vsmxenc (void);
-void retrieve_from_opts (Bool warnUnk, int num, ...);
+void retrieve_from_opts (uint8_t warnUnk, int num, ...);
-Bool quietMode;
+uint8_t quietMode;
int app_argc;
char **app_argv;
-extern Bool suppressDecompWarnings;
+extern uint8_t suppressDecompWarnings;
int
main (int argc, char **argv)
" The following options only apply for extracting text resources.\n"
" --lang <lang> Language of text to extract. [English]\n"
" You can use a language ID or one of the following:\n");
- uint i = 0;
+ uint32_t i = 0;
while (RCOXML_TABLE_TEXT_LANG[i][0]) {
printf (" - %s (ID=%d)\n",
char *sRcoFile = NULL;
char *sXmlFile = NULL;
- Bool sTextOutput = FALSE;
+ uint8_t sTextOutput = FALSE;
// char curPath[] = ".";
char *sResDir = NULL;
// char* sConvGim = NULL;
RcoDumpGimconvOpts gimconvOpts;
- Bool sConvVag = FALSE;
- Bool sConvVsmx = FALSE;
+ uint8_t sConvVag = FALSE;
+ uint8_t sConvVsmx = FALSE;
int i;
}
// dump resources
char textPathPrefix[MAX_FILENAME_LEN] = "\0";
- Bool sndDumped = FALSE;
+ uint8_t sndDumped = FALSE;
if ((!sResDir || strcmp (sResDir, "-"))
&& (rco->tblImage || rco->tblSound || rco->tblModel || rco->tblVSMX ||
char *sResLabel = NULL;
char *sOutFile = NULL;
char *stTextLang = NULL;
- uint sTextLang = 1;
- Bool sTextNoHdr = FALSE;
+ uint32_t sTextLang = 1;
+ uint8_t sTextNoHdr = FALSE;
int sSndChannel = 1;
int i;
if (fp) {
if (!sTextNoHdr) {
if (rte->format == RCO_TEXT_FMT_UTF32) {
- uint32 bom = UTF32_BOM;
+ uint32_t bom = UTF32_BOM;
if (rco->eSwap)
bom = ENDIAN_SWAP (bom);
filewrite (fp, &bom, sizeof (bom));
} else if (rte->format == RCO_TEXT_FMT_UTF8) {
- uint32 bom = UTF8_BOM;
+ uint32_t bom = UTF8_BOM;
filewrite (fp, &bom, 3);
} else {
- uint16 bom = UTF16_BOM;
+ uint16_t bom = UTF16_BOM;
if (rco->eSwap)
bom = ENDIAN_SWAP (bom);
char *sXmlFile = NULL;
char *sRcoFile = NULL;
- Bool sNoConvGim = FALSE;
- Bool sNoConvVag = FALSE;
- Bool sNoConvVsmx = FALSE;
+ uint8_t sNoConvGim = FALSE;
+ uint8_t sNoConvVag = FALSE;
+ uint8_t sNoConvVsmx = FALSE;
RcoDumpGimconvOpts gimconvOpts;
gimconvOpts.cmd = gimconvOpts.extFlags = NULL;
if (app_argc < 4)
MAIN_INV_CMD_SYNTAX;
- uint channels = app_argc - 3;
+ uint32_t channels = app_argc - 3;
int i;
int *len = (int *) malloc (channels * sizeof (int));
void **buf = (void **) malloc (channels * sizeof (void *));
warning ("Unable to open file %s", app_argv[i]);
}
- Bool success = vag2wav (app_argv[app_argc - 1], channels, len, buf);
+ uint8_t success = vag2wav (app_argv[app_argc - 1], channels, len, buf);
free (len);
while (channels--)
if (app_argc < 4)
MAIN_INV_CMD_SYNTAX;
- uint i, channels; // = app_argc-3;
- uint len;
+ uint32_t i, channels; // = app_argc-3;
+ uint32_t len;
void *buf;
channels = wav2vag (app_argv[2], &len, &buf, "");
}
// trim .vag extension if autogenerating that
if (app_argc - 3 == 1 && channels > 1) {
- uint nl = strlen (app_argv[3]);
+ uint32_t nl = strlen (app_argv[3]);
if (nl > MAX_FILENAME_LEN)
app_argv[3][MAX_FILENAME_LEN] = '\0';
app_argv[3][nl - 4] = '\0';
}
- Bool writeStdout = !strcmp (app_argv[3], "-");
+ uint8_t writeStdout = !strcmp (app_argv[3], "-");
for (i = 0; i < channels; i++) {
FILE *fp;
if (app_argc < 4)
MAIN_INV_CMD_SYNTAX;
- Bool doDecompile = FALSE;
+ uint8_t doDecompile = FALSE;
FILE *fin = NULL, *fout = NULL;
retrieve_from_opts (TRUE, 1, "--decompile", "bool", &doDecompile);
VsmxMem *vm = readVSMX (fin);
fclose (fin);
- Bool success = FALSE;
+ uint8_t success = FALSE;
if (vm) {
info ("Writing decoded output...");
}
}
- void retrieve_from_opts (Bool warnUnk, int num, ...) {
+ void retrieve_from_opts (uint8_t warnUnk, int num, ...) {
int i, j;
va_list ap;
char *type = va_arg (ap, char *);
if (!strcmp (type, "bool"))
- *(va_arg (ap, Bool *)) = TRUE;
+ *(va_arg (ap, uint8_t *)) = TRUE;
else if (i + 1 < app_argc) {
app_argv[i] = NULL;
char *val = app_argv[++i];
#include "vaghandler.h"
#include "vsmx.h"
-Bool exec_gimconv (char *cmd, char *src, char *dest, char *extFlags);
+uint8_t exec_gimconv (char *cmd, char *src, char *dest, char *extFlags);
-Bool
+uint8_t
dump_resource (char *dest, rRCOEntry * entry, OutputDumpFunc outputfunc,
void *outputfuncArg)
{
return FALSE;
}
- uint len = 0;
- uint8 *bufferMid = (uint8 *) read_resource (entry, &len);
+ uint32_t len = 0;
+ uint8_t *bufferMid = (uint8_t *) read_resource (entry, &len);
if (!bufferMid)
return FALSE;
if (len != entry->srcLenUnpacked)
warning ("Extracted resource size for does not match specified length.");
- Bool ret = outputfunc (dest, (void *) bufferMid, entry, outputfuncArg);
+ uint8_t ret = outputfunc (dest, (void *) bufferMid, entry, outputfuncArg);
free (bufferMid);
return ret;
}
-Bool
+uint8_t
dump_output_data (char *dest, void *buf, rRCOEntry * entry, void *arg)
{
FILE *fp = openwrite (dest);
return FALSE;
}
-Bool
+uint8_t
dump_output_wav (char *dest, void *buf, rRCOEntry * entry, void *arg)
{
int i;
void **vagData = (void **) malloc (rse->channels * sizeof (void *));
int *vagLen = (int *) malloc (rse->channels * sizeof (int));
- Bool ret;
+ uint8_t ret;
for (i = 0; i < rse->channels; i++) {
vagLen[i] = rse->channelData[i * 2];
return ret;
}
-Bool
+uint8_t
dump_output_gimconv (char *dest, void *buf, rRCOEntry * entry, void *arg)
{
#ifdef WIN32
char tmpName[255];
- static uint successes = 0, failures = 0;
+ static uint32_t successes = 0, failures = 0;
RcoDumpGimconvOpts *opts = (RcoDumpGimconvOpts *) arg;
- Bool ret;
+ uint8_t ret;
if (failures <= 5 || successes > 0) {
if (entry->srcLenUnpacked > 0x28) {
// dirty code - we'll leave here, since the internal converter will have
// nicer code :P
- uint32 *i32;
- Bool es = FALSE;
+ uint32_t *i32;
+ uint8_t es = FALSE;
- i32 = (uint32 *) buf;
+ i32 = (uint32_t *) buf;
if (*i32 == 0x4D49472E)
es = TRUE; // .GIM
if (*i32 == 0x2E47494D || *i32 == 0x4D49472E) {
- uint16 i, i2;
+ uint16_t i, i2;
- i = *(uint16 *) ((char *) buf + 0x10);
- i2 = *(uint16 *) ((char *) buf + 0x20);
+ i = *(uint16_t *) ((char *) buf + 0x10);
+ i2 = *(uint16_t *) ((char *) buf + 0x20);
if (es) {
i = ENDIAN_SWAP (i);
i2 = ENDIAN_SWAP (i2);
}
if (i == 2 && i2 == 3) {
- uint32 sz = *(uint32 *) ((char *) buf + 0x14), sz2;
+ uint32_t sz = *(uint32_t *) ((char *) buf + 0x14), sz2;
- i32 = (uint32 *) ((char *) buf + 0x24);
+ i32 = (uint32_t *) ((char *) buf + 0x24);
sz2 = *i32;
if (es) {
sz = ENDIAN_SWAP (sz);
#endif
}
-Bool
+uint8_t
dump_output_vsmxdec (char *dest, void *buf, rRCOEntry * entry, void *arg)
{
VsmxMem *vm = readVSMXMem (buf);
return;
char fullOutName[MAX_FILENAME_LEN];
- uint extMapLen = 0;
+ uint32_t extMapLen = 0;
char dat[5] = "dat";
strcpy (fullOutName, pathPrefix);
extMapLen++;
#define MAX_LABEL_LEN 216
- uint i;
+ uint32_t i;
rRCOEntry *entry;
for (entry = parent->firstChild; entry; entry = entry->next) {
char *ext = (char *) dat;
if (entry->id == RCO_TABLE_IMG || entry->id == RCO_TABLE_MODEL) {
- uint fmt = ((rRCOImgModelEntry *) entry->extra)->format;
+ uint32_t fmt = ((rRCOImgModelEntry *) entry->extra)->format;
if (fmt == RCO_IMG_GIM && outputFilterArg) {
ext = ((RcoDumpGimconvOpts *) outputFilterArg)->ext;
char *label = get_label_from_offset (labels, entry->labelOffset);
- uint len = strlen (label);
+ uint32_t len = strlen (label);
if (len > MAX_LABEL_LEN)
len = MAX_LABEL_LEN;
strcpy (outName + strlen (outName), ext);
- uint origAddr = entry->srcAddr, origLen =
+ uint32_t origAddr = entry->srcAddr, origLen =
entry->srcLen, origLenUnpacked = entry->srcLenUnpacked;
entry->srcLen = entry->srcLenUnpacked =
((rRCOSoundEntry *) entry->extra)->channelData[i * 2];
* strcpy(outName + len +1, ext);
*
* // trick dump_resource() into doing what we want it to by fiddling with
- * stuff uint origAddr = entry->srcAddr, origLen = entry->srcLen,
+ * stuff uint32_t origAddr = entry->srcAddr, origLen = entry->srcLen,
* origLenUnpacked = entry->srcLenUnpacked; if(entry->id ==
* RCO_TABLE_SOUND) { entry->srcLen = entry->srcLenUnpacked =
* ((rRCOSoundEntry*)entry->extra)->channelData[j*2]; entry->srcAddr +=
}
void
-dump_text_resources (char *labels, rRCOEntry * parent, Bool writeHeader,
- char *pathPrefix, Bool bWriteXML)
+dump_text_resources (char *labels, rRCOEntry * parent, uint8_t writeHeader,
+ char *pathPrefix, uint8_t bWriteXML)
{
if (!parent || !parent->numSubentries)
return;
char fullOutName[MAX_FILENAME_LEN];
#define MAX_LABEL_LEN 216
- uint i;
+ uint32_t i;
rRCOEntry *entry;
for (entry = parent->firstChild; entry; entry = entry->next) {
for (i = 0; i < textEntry->numIndexes; i++) {
RCOTextIndex *idx = &(textEntry->indexes[i]);
- uint len = strlen (get_label_from_offset (labels, idx->labelOffset));
- uint dataLen = 0;
+ uint32_t len = strlen (get_label_from_offset (labels, idx->labelOffset));
+ uint32_t dataLen = 0;
if (len > MAX_LABEL_LEN)
len = MAX_LABEL_LEN;
if (idx->length) {
- uint charWidth = RCO_TEXT_FMT_CHARWIDTH (textEntry->format);
+ uint32_t charWidth = RCO_TEXT_FMT_CHARWIDTH (textEntry->format);
dataLen = idx->length;
if (idx->length >= charWidth) {
}
if (writeHeader) {
if (textEntry->format == RCO_TEXT_FMT_UTF32) {
- uint32 bom = UTF32_BOM;
+ uint32_t bom = UTF32_BOM;
if (parent->rco->eSwap)
bom = ENDIAN_SWAP (bom);
filewrite (fp, &bom, sizeof (bom));
} else if (textEntry->format == RCO_TEXT_FMT_UTF8) {
- uint32 bom = UTF8_BOM;
+ uint32_t bom = UTF8_BOM;
filewrite (fp, &bom, 3);
} else {
- uint16 bom = UTF16_BOM;
+ uint16_t bom = UTF16_BOM;
if (parent->rco->eSwap)
bom = ENDIAN_SWAP (bom);
fclose (fp);
} else {
char *bufIn = textBuffer + idx->offset;
- Bool useCdata = (memchr (bufIn, '<', dataLen)
+ uint8_t useCdata = (memchr (bufIn, '<', dataLen)
|| memchr (bufIn, '>', dataLen)
|| memchr (bufIn, '&', dataLen));
char buf[4096];
char *bufOut = buf;
- uint outBufLen = 4096;
+ uint32_t outBufLen = 4096;
- /* { // feed in the BOM (is it really necessary though?) uint number;
+ /* { // feed in the BOM (is it really necessary though?) uint32_t number;
* char* unicodePtr; if(textEntry->format == RCO_TEXT_FMT_UTF32) {
- * uint32 bom = UTF32_BOM; if(parent->rco->eSwap) bom =
+ * uint32_t bom = UTF32_BOM; if(parent->rco->eSwap) bom =
* ENDIAN_SWAP(bom); number = sizeof(bom); unicodePtr = (char*)&bom;
* iconv(ic, (const char**)(&unicodePtr), (size_t*)(&number), &bufOut,
* (size_t*)(&outBufLen)); } else if(textEntry->format ==
- * RCO_TEXT_FMT_UTF8) { uint32 bom = UTF8_BOM; number = 3; unicodePtr =
+ * RCO_TEXT_FMT_UTF8) { uint32_t bom = UTF8_BOM; number = 3; unicodePtr =
* (char*)&bom; iconv(ic, (const char**)(&unicodePtr),
- * (size_t*)(&number), &bufOut, (size_t*)(&outBufLen)); } else { uint16
+ * (size_t*)(&number), &bufOut, (size_t*)(&outBufLen)); } else { uint16_t
* bom = UTF16_BOM; if(parent->rco->eSwap) bom = ENDIAN_SWAP(bom);
* number = sizeof(bom); unicodePtr = (char*)&bom; iconv(ic, (const
* char**)(&unicodePtr), (size_t*)(&number), &bufOut,
* (size_t*)(&outBufLen)); } } */
- uint nullsStripped = 0;
+ uint32_t nullsStripped = 0;
while (dataLen) {
iconv (ic, (&bufIn), (size_t *) (&dataLen), &bufOut,
if (entry->srcFile[0] && entry->srcAddr == 0 &&
entry->srcCompression == RCO_DATA_COMPRESSION_NONE &&
!strcasecmp (entry->srcFile + strlen (entry->srcFile) - 4, ".wav")) {
- uint len;
+ uint32_t len;
int i;
rse->channels = wav2vag (entry->srcFile, &len, &entry->srcBuffer, "");
if (!rse->channelData)
rse->channelData =
- (uint32 *) malloc (rse->channels * sizeof (uint32) * 2);
+ (uint32_t *) malloc (rse->channels * sizeof (uint32_t) * 2);
for (i = 0; i < rse->channels; i++) {
rse->channelData[i * 2] = len;
rse->channelData[i * 2 + 1] = len * i;
get_label_from_offset (rco->labels, entry->labelOffset));
}
-Bool
+uint8_t
exec_gimconv (char *cmd, char *src, char *dest, char *extFlags)
{
#ifdef WIN32
#ifndef __RCODUMP_H__
#define __RCODUMP_H__
-typedef Bool (*OutputDumpFunc) (char *, void *, rRCOEntry *, void *);
+typedef uint8_t (*OutputDumpFunc) (char *, void *, rRCOEntry *, void *);
typedef struct {
char *cmd;
char *extFlags;
} RcoDumpGimconvOpts;
-Bool dump_resource (char *dest, rRCOEntry * entry, OutputDumpFunc outputfunc,
+uint8_t dump_resource (char *dest, rRCOEntry * entry, OutputDumpFunc outputfunc,
void *outputfuncArg);
void dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap,
char *pathPrefix, void *outputFilterArg);
-void dump_text_resources (char *labels, rRCOEntry * parent, Bool writeHeader,
- char *pathPrefix, Bool bWriteXML);
-Bool dump_output_data (char *dest, void *buf, rRCOEntry * entry, void *arg);
-Bool dump_output_vsmxdec (char *dest, void *buf, rRCOEntry * entry, void *arg);
+void dump_text_resources (char *labels, rRCOEntry * parent, uint8_t writeHeader,
+ char *pathPrefix, uint8_t bWriteXML);
+uint8_t dump_output_data (char *dest, void *buf, rRCOEntry * entry, void *arg);
+uint8_t dump_output_vsmxdec (char *dest, void *buf, rRCOEntry * entry, void *arg);
void compile_gimconv_map (rRCOFile * rco, rRCOEntry * entry, void *arg);
void compile_vagconv_map (rRCOFile * rco, rRCOEntry * entry, void *arg);
#define RCO_SIGNATURE 0x46525000 // .PRF (PSP Resource File?)
PACK_STRUCT (PRFHeader, {
- uint32 signature; // RCO_SIGNATURE
- uint32 version;
+ uint32_t signature; // RCO_SIGNATURE
+ uint32_t version;
// 0x70 - UMD RCOs (video?), FW1.00
// 0x71 - UMD RCOs (audio?), FW1.50, FW2.50
// 0x90 - FW2.60
// 0x95 - FW2.70, FW2.71
// 0x96 - FW2.80, FW2.82, FW3.00, FW3.03, FW3.10, FW3.30, FW3.40
// 0x100 - FW3.50, FW3.52, FW5.00, FW5.55
- uint32 null;
- uint32 compression; // upper nibble = compression, lower nibble:
+ uint32_t null;
+ uint32_t compression; // upper nibble = compression, lower nibble:
// 0=flash0 RCOs, 1=UMD RCOs????
/*
* #define RCO_COMPRESSION_NONE 0x00 // entries for 0x01 ?? #define
* RCO_COMPRESSION_ZLIB 0x10 #define RCO_COMPRESSION_RLZ 0x20 */
// main table pointers
- uint32 pMainTable; // type 1
- uint32 pVSMXTable; // type 2
- uint32 pTextTable; // type 3
- uint32 pSoundTable; // type 5
- uint32 pModelTable; // type 6
- uint32 pImgTable; // type 4
- uint32 pUnknown; // always 0xFFFFFFFF
- uint32 pFontTable; // type 7
- uint32 pObjTable; // type 8
- uint32 pAnimTable; // type 9
+ uint32_t pMainTable; // type 1
+ uint32_t pVSMXTable; // type 2
+ uint32_t pTextTable; // type 3
+ uint32_t pSoundTable; // type 5
+ uint32_t pModelTable; // type 6
+ uint32_t pImgTable; // type 4
+ uint32_t pUnknown; // always 0xFFFFFFFF
+ uint32_t pFontTable; // type 7
+ uint32_t pObjTable; // type 8
+ uint32_t pAnimTable; // type 9
// text stuff
- uint32 pTextData; // NOTE: this may == pLabelData if lTextData ==
+ uint32_t pTextData; // NOTE: this may == pLabelData if lTextData ==
// 0
- uint32 lTextData; uint32 pLabelData; uint32 lLabelData;
- uint32 pEventData;
- uint32 lEventData;
+ uint32_t lTextData; uint32_t pLabelData; uint32_t lLabelData;
+ uint32_t pEventData;
+ uint32_t lEventData;
// pointer data
- uint32 pTextPtrs; uint32 lTextPtrs; uint32 pImgPtrs; uint32 lImgPtrs;
- uint32 pModelPtrs; uint32 lModelPtrs;
- uint32 pSoundPtrs;
- uint32 lSoundPtrs; uint32 pObjPtrs; uint32 lObjPtrs;
- uint32 pAnimPtrs;
- uint32 lAnimPtrs;
+ uint32_t pTextPtrs; uint32_t lTextPtrs; uint32_t pImgPtrs; uint32_t lImgPtrs;
+ uint32_t pModelPtrs; uint32_t lModelPtrs;
+ uint32_t pSoundPtrs;
+ uint32_t lSoundPtrs; uint32_t pObjPtrs; uint32_t lObjPtrs;
+ uint32_t pAnimPtrs;
+ uint32_t lAnimPtrs;
// attached data
- uint32 pImgData;
- uint32 lImgData; uint32 pSoundData; uint32 lSoundData;
- uint32 pModelData;
- uint32 lModelData;
+ uint32_t pImgData;
+ uint32_t lImgData; uint32_t pSoundData; uint32_t lSoundData;
+ uint32_t pModelData;
+ uint32_t lModelData;
// always 0xFFFFFFFF
- uint32 unknown[3];
+ uint32_t unknown[3];
});
PACK_STRUCT (RCOEntry, {
- // uint8 type; // main table uses 0x01; may be used as a current entry
+ // uint8_t type; // main table uses 0x01; may be used as a current entry
// depth value
- // uint8 id;
- uint16 typeId;
- uint16 blank;
- uint32 labelOffset;
- uint32 eHeadSize; // = sizeof(RCOEntry) = 0x28 [ only used for
+ // uint8_t id;
+ uint16_t typeId;
+ uint16_t blank;
+ uint32_t labelOffset;
+ uint32_t eHeadSize; // = sizeof(RCOEntry) = 0x28 [ only used for
// entries with extra info (ie not "main"
// entries) ]
- uint32 entrySize; // main tables (main/img etc) uses 0x28 here,
+ uint32_t entrySize; // main tables (main/img etc) uses 0x28 here,
// or is this the length of current entry (not
// including subentries)?
// 0x10
- uint32 numSubentries;
- uint32 nextEntryOffset;
- uint32 prevEntryOffset; // this is usually 0x0 however (does make
+ uint32_t numSubentries;
+ uint32_t nextEntryOffset;
+ uint32_t prevEntryOffset; // this is usually 0x0 however (does make
// writing RCOs easier though :P I guess Sony's
// tools do something similar...)
- uint32 parentTblOffset; // offset of this entry from parent table
+ uint32_t parentTblOffset; // offset of this entry from parent table
// 0x20
- uint32 blanks[2];
+ uint32_t blanks[2];
});
PACK_STRUCT (RCOVSMXEntry, {
- uint32 offset; // always 0x0, so I assume this is an offset
- uint32 length; // length of VSMX file
+ uint32_t offset; // always 0x0, so I assume this is an offset
+ uint32_t length; // length of VSMX file
});
#define RCO_LANG_JAPANESE 0x0
#define RCO_TEXT_FMT_UTF16 0x1
#define RCO_TEXT_FMT_UTF32 0x2
PACK_STRUCT (RCOTextEntry, {
- uint16 lang;
- uint16 format;
- uint32 numIndexes;
+ uint16_t lang;
+ uint16_t format;
+ uint32_t numIndexes;
});
PACK_STRUCT (RCOTextIndex, {
- uint32 labelOffset;
- uint32 length;
- uint32 offset;
+ uint32_t labelOffset;
+ uint32_t length;
+ uint32_t offset;
});
#define RCO_DATA_COMPRESSION_NONE 0x0
#define RCO_IMG_GIM 0x5
#define RCO_MODEL_GMO 0x0
PACK_STRUCT (RCOImgModelEntry, {
- uint16 format;
- uint16 compression; // RCO_DATA_COMPRESSION_* constants
- uint32 sizePacked;
- uint32 offset;
- uint32 sizeUnpacked; // this value doesn't exist if entry isn't
+ uint16_t format;
+ uint16_t compression; // RCO_DATA_COMPRESSION_* constants
+ uint32_t sizePacked;
+ uint32_t offset;
+ uint32_t sizeUnpacked; // this value doesn't exist if entry isn't
// compressed
});
// note, some image/model entries which aren't compressed, don't have the last
// member
PACK_STRUCT (RCOPS3ImgModelEntry, { // PS3 version of the above
- uint16 format;
- uint16 compression; // RCO_DATA_COMPRESSION_* constants
- uint32 sizePacked;
- uint32 offset;
- uint32 something; // PS3 RCOs seem to have this extra element -
+ uint16_t format;
+ uint16_t compression; // RCO_DATA_COMPRESSION_* constants
+ uint32_t sizePacked;
+ uint32_t offset;
+ uint32_t something; // PS3 RCOs seem to have this extra element -
// probably something to do with
// planes/frames?? usually 0x1
- uint32 sizeUnpacked; // this value doesn't exist if entry isn't
+ uint32_t sizeUnpacked; // this value doesn't exist if entry isn't
// compressed
});
#define RCO_SOUND_VAG 0x1
PACK_STRUCT (RCOSoundEntry, {
- uint16 format; // 0x01 = VAG
- uint16 channels; // 1 or 2 channels
- uint32 sizeTotal;
- uint32 offset;
+ uint16_t format; // 0x01 = VAG
+ uint16_t channels; // 1 or 2 channels
+ uint32_t sizeTotal;
+ uint32_t offset;
// now pairs of size/offset for each channel
});
PACK_STRUCT (RCOFontEntry, {
- uint16 format; // 1
- uint16 compression; // 0
- uint32 unknown; // 0
- uint32 unknown2;
+ uint16_t format; // 1
+ uint16_t compression; // 0
+ uint32_t unknown; // 0
+ uint32_t unknown2;
});
#define RCO_OBJ_TYPE_PAGE 0x1
#define RCO_REF_OBJ 0x409 // absolute
#define RCO_REF_NONE 0xFFFF
PACK_STRUCT (RCOReference, {
- uint32 type;
- uint32 ptr;
+ uint32_t type;
+ uint32_t ptr;
});
#define RCO_ANIM_TYPE_POS 0x2
#define RCO_ANIM_TYPE_0B 0xB // only appears on UMD RCOs?
PACK_STRUCT (HeaderComprInfo, {
- uint32 lenPacked;
- uint32 lenUnpacked;
- uint32 lenLongestText; // length of the longest language's text data
+ uint32_t lenPacked;
+ uint32_t lenUnpacked;
+ uint32_t lenLongestText; // length of the longest language's text data
// (unpacked)
});
PACK_STRUCT (TextComprInfo, {
- uint16 lang;
- uint16 unknown; // always 0x1
- uint32 nextOffset; // = ALIGN_TO_4(sizeof(TextComprInfo) +
+ uint16_t lang;
+ uint16_t unknown; // always 0x1
+ uint32_t nextOffset; // = ALIGN_TO_4(sizeof(TextComprInfo) +
// packedLen); is 0 for last text entry
// regardless of what actually comes after
- uint32 packedLen;
- uint32 unpackedLen;
+ uint32_t packedLen;
+ uint32_t unpackedLen;
});
#endif
#include <string.h>
#include "rcomain.h"
-Bool suppressDecompWarnings = FALSE;
+uint8_t suppressDecompWarnings = FALSE;
void
free_rco (rRCOFile * f)
}
char *
-get_label_from_offset (char *labels, uint labelOffset)
+get_label_from_offset (char *labels, uint32_t labelOffset)
{
static char labelBuf[255];
* parent->subentries = (rRCOEntry*)realloc(parent->subentries,
* sizeof(rRCOEntry) * (parent->numSubentries+1)); if(pos == -1) dest =
* &(parent->subentries[parent->numSubentries]); else { // shift things up by
- * one place dest = &(parent->subentries[pos]); uint numEntriesToMove =
+ * one place dest = &(parent->subentries[pos]); uint32_t numEntriesToMove =
* parent->numSubentries - pos; //rRCOEntry* tmpBuffer = (rRCOEntry*)malloc()
* memcpy(&(parent->subentries[pos+1]), &(parent->subentries[pos]),
* numEntriesToMove * sizeof(rRCOEntry)); } }
fileread (fp, inBuf, entry->srcLen);
fclose (fp);
- uint unpackedLen = zlib_unpacked_size (inBuf, entry->srcLen);
+ uint32_t unpackedLen = zlib_unpacked_size (inBuf, entry->srcLen);
if (unpackedLen != 0xFFFFFFFF) {
if (entry->srcLenUnpacked != 0xFFFFFFFF &&
}
void *
-read_resource (rRCOEntry * entry, uint * outLen)
+read_resource (rRCOEntry * entry, uint32_t * outLen)
{
char *bufferMid;
if (entry->srcAddr < sizeof (PRFHeader))
return NULL;
PRFHeader header;
- Bool eSwap;
+ uint8_t eSwap;
fileread (src, &header, sizeof (header));
eSwap = (header.signature == ENDIAN_SWAP_32 (RCO_SIGNATURE));
return bufferMid;
}
-uint
+uint32_t
count_all_subentries (rRCOEntry * entry)
{
- uint entries = entry->numSubentries;
+ uint32_t entries = entry->numSubentries;
rRCOEntry *rcoNode;
for (rcoNode = entry->firstChild; rcoNode; rcoNode = rcoNode->next)
rRCOEntry **children =
(rRCOEntry **) malloc (parent->numSubentries * sizeof (rRCOEntry *));
children[0] = parent->firstChild;
- uint i;
+ uint32_t i;
for (i = 1; i < parent->numSubentries; i++)
children[i] = children[i - 1]->next;
if (!textExtra->numIndexes)
return -1;
- uint i;
+ uint32_t i;
for (i = 0; i < textExtra->numIndexes; i++) {
if (!strcmp (labels + textExtra->indexes[i].labelOffset, s))
}
void
-make_iconv_charset (char out[8], int fmt, Bool es)
+make_iconv_charset (char out[8], int fmt, uint8_t es)
{
strcpy (out, "ucs-2le");
if (es)
}
void
-es_extraObjAnim (Bool isObj, int type, void *data, Bool isPS3)
+es_extraObjAnim (uint8_t isObj, int type, void *data, uint8_t isPS3)
{
if (type == 0)
return;
- uint len = 0;
+ uint32_t len = 0;
const int *typeArray;
if (isObj && type <= (int) RCO_OBJ_EXTRA_LEN_NUM) {
if (!len)
return;
- uint i = 0, i2 = 0;
- uint32 *uData = (uint32 *) data;
+ uint32_t i = 0, i2 = 0;
+ uint32_t *uData = (uint32_t *) data;
#define ENDIAN_SWAP_HALF32(x) (((x) & 0xFF) << 8 | ((x) & 0xFF00) >> 8 | ((x) & 0xFF0000) << 8 | ((x) & 0xFF000000) >> 8)
} writerco_options;
typedef struct __rRCOEntry {
- uint8 type; // main table uses 0x01; may be used as a
+ uint8_t type; // main table uses 0x01; may be used as a
// current entry depth value
- uint8 id;
+ uint8_t id;
// char* label;
- uint labelOffset;
+ uint32_t labelOffset;
- uint offset; // absolute offset of this entry in file (only
+ uint32_t offset; // absolute offset of this entry in file (only
// used when reading/writing RCOs - means
// nothing otherwise; also, writing the RCO may
// change this value)
struct __rRCOEntry *lastChild;
struct __rRCOEntry *prev;
struct __rRCOEntry *next;
- uint numSubentries;
+ uint32_t numSubentries;
void *extra;
- uint extraLen; // in bytes
+ uint32_t extraLen; // in bytes
// for entries with attached data
char srcFile[MAX_FILENAME_LEN];
- uint srcAddr;
- uint srcLen;
- uint srcLenUnpacked;
- uint srcCompression; // use RCO_DATA_COMPRESSION_* constants in
+ uint32_t srcAddr;
+ uint32_t srcLen;
+ uint32_t srcLenUnpacked;
+ uint32_t srcCompression; // use RCO_DATA_COMPRESSION_* constants in
// rcofile.h
void *srcBuffer; // work around for reading XML; should only be
// used for sound and text entries; need to
} rRCOEntry;
typedef struct {
- uint16 lang;
- uint16 format;
- uint32 numIndexes;
+ uint16_t lang;
+ uint16_t format;
+ uint32_t numIndexes;
RCOTextIndex *indexes;
} rRCOTextEntry;
-/* packed_struct { char* label; uint length; uint32 offset; } rRCOTextIndex; */
+/* packed_struct { char* label; uint32_t length; uint32_t offset; } rRCOTextIndex; */
typedef struct {
rRCOEntry *textEntry;
RCOTextIndex *index;
rRCOEntry tblMain;
char *labels;
- uint labelsLen;
+ uint32_t labelsLen;
char *events;
- uint eventsLen;
+ uint32_t eventsLen;
/*
- * // pointer segments rRCOTextIdxPtr* ptrText; uint numPtrText; rRCOEntry**
- * ptrImg; uint numPtrImg; rRCOEntry** ptrModel; uint numPtrModel;
- * rRCOEntry** ptrSound; uint numPtrSound; rRCOEntry** ptrObj; uint
- * numPtrObj; rRCOEntry** ptrAnim; uint numPtrAnim; */
+ * // pointer segments rRCOTextIdxPtr* ptrText; uint32_t numPtrText; rRCOEntry**
+ * ptrImg; uint32_t numPtrImg; rRCOEntry** ptrModel; uint32_t numPtrModel;
+ * rRCOEntry** ptrSound; uint32_t numPtrSound; rRCOEntry** ptrObj; uint32_t
+ * numPtrObj; rRCOEntry** ptrAnim; uint32_t numPtrAnim; */
// shortcuts
rRCOEntry *tblVSMX;
// additional info about the source (mainly used for displaying info about
// the RCO)
- uint32 verId; // offset 0x04 in file
- uint umdFlag;
- uint headerCompression;
- Bool eSwap;
- Bool ps3;
+ uint32_t verId; // offset 0x04 in file
+ uint32_t umdFlag;
+ uint32_t headerCompression;
+ uint8_t eSwap;
+ uint8_t ps3;
} rRCOFile;
typedef struct {
- uint32 type;
+ uint32_t type;
void *ptr; // will usu be rRCOEntry*, but may be char* for
// events; NULL if type is nothing
- uint32 rawPtr; // raw value from source - means nothing if
+ uint32_t rawPtr; // raw value from source - means nothing if
// type is known
} rRCORef;
typedef struct {
- uint format;
- uint compression;
- uint unkCompr; // unknown - usually 0, some PS3 rcos have 1
+ uint32_t format;
+ uint32_t compression;
+ uint32_t unkCompr; // unknown - usually 0, some PS3 rcos have 1
// here
} rRCOImgModelEntry;
typedef struct {
- uint16 format; // 0x01 = VAG
- uint16 channels; // 1 or 2 channels
- uint32 *channelData; // size/offset pairs
+ uint16_t format; // 0x01 = VAG
+ uint16_t channels; // 1 or 2 channels
+ uint32_t *channelData; // size/offset pairs
} rRCOSoundEntry;
typedef struct {
- uint format; // 1
- uint compression; // 0
- uint unknown;
- uint unknown2;
+ uint32_t format; // 1
+ uint32_t compression; // 0
+ uint32_t unknown;
+ uint32_t unknown2;
} rRCOFontEntry;
#define RCO_TEXT_FMT_CHARWIDTH(t) ((t) == RCO_TEXT_FMT_UTF32 ? 4 : (((t) == RCO_TEXT_FMT_UTF8)) ? 1 : 2)
typedef int ((*RcoObjTypes)[RCO_OBJMAP_SIZE]);
extern int *RCO_OBJ_EXTRA_LEN;
-extern uint RCO_OBJ_EXTRA_LEN_NUM;
+extern uint32_t RCO_OBJ_EXTRA_LEN_NUM;
#define RCO_OBJANIM_IS_REF(v) (\
(v == RCO_OBJ_EXTRA_TYPE_REF) || \
extern RcoObjTypes RCO_OBJ_EXTRA_TYPES;
extern int *RCO_ANIM_EXTRA_LEN;
-extern uint RCO_ANIM_EXTRA_LEN_NUM;
+extern uint32_t RCO_ANIM_EXTRA_LEN_NUM;
// this doesn't include references
extern RcoObjMap RCO_ANIM_EXTRA_NAMES;
extern RcoObjTypes RCO_ANIM_EXTRA_TYPES;
rRCOFile *read_rco (char *fn);
-Bool write_rco (rRCOFile * rco, char *fn, writerco_options opts);
+uint8_t write_rco (rRCOFile * rco, char *fn, writerco_options opts);
void free_rco (rRCOFile * f);
void rco_map_func (rRCOFile * rco, rRCOEntry * parent, void *arg,
void (*func) (rRCOFile * rco, rRCOEntry * entry, void *arg));
-char *get_label_from_offset (char *labels, uint labelOffset);
-void *read_resource (rRCOEntry * entry, uint * outLen);
+char *get_label_from_offset (char *labels, uint32_t labelOffset);
+void *read_resource (rRCOEntry * entry, uint32_t * outLen);
#define RCO_DATA_COMPRESSION_RCO 0xFF
void rco_fix_decomp_sizes (rRCOFile * rco, rRCOEntry * entry);
-uint count_all_subentries (rRCOEntry * entry);
+uint32_t count_all_subentries (rRCOEntry * entry);
rRCOEntry **make_sorted_list_of_subentries (rRCOEntry * parent,
int (*compar) (const rRCOEntry **, const rRCOEntry **));
int find_text_from_label (char *labels, rRCOTextEntry * textExtra,
const char *s);
-void make_iconv_charset (char out[8], int fmt, Bool es);
+void make_iconv_charset (char out[8], int fmt, uint8_t es);
void es_rcoHeader (PRFHeader * h);
void es_rcoEntry (RCOEntry * e);
void es_rcoSoundEntry (RCOSoundEntry * e);
void es_headerComprInfo (HeaderComprInfo * hci);
void es_textComprInfo (TextComprInfo * tci);
-void es_extraObjAnim (Bool isObj, int type, void *data, Bool isPS3);
+void es_extraObjAnim (uint8_t isObj, int type, void *data, uint8_t isPS3);
PACK_STRUCT (RCOObjPos, {
float posX;
float sclY; // scale values
float elemScale;
- uint32 iconOffset; // unknown weird value, appears to affect icon
+ uint32_t iconOffset; // unknown weird value, appears to affect icon
// offsetting. Only lowest byte appears to have
// any effects - upper nibble appears to affect
// Y offset, and lower nibble affects X offset
});
/*
- * PACK_STRUCT(RCOObjSPage, { uint32 unknown; // usu 0x111, sometimes 0xFFFF
+ * PACK_STRUCT(RCOObjSPage, { uint32_t unknown; // usu 0x111, sometimes 0xFFFF
* (only seen in UMD video RCOs) rRCORef event1; rRCORef event2; rRCORef
* event3; rRCORef event4; }); // 0x01 PACK_STRUCT(RCOObjSPlane, { RCOObjPos
- * pos; rRCORef image; uint32 unknownH; // either 0 or 0xFFFF. Has weird
+ * pos; rRCORef image; uint32_t unknownH; // either 0 or 0xFFFF. Has weird
* effect on height. Upper 2 bytes seem to have no effect. }); // 0x02
* PACK_STRUCT(RCOObjSButton, { // this page seems to be for buttons/pane
* items. for "buttons", has events for "Push", "FocusIn", "FocusOut" etc
* RCOObjPos pos; rRCORef image; rRCORef shadow; // usu this & above images are
* img/shadow pairs rRCORef image2; rRCORef ref; rRCORef event1; rRCORef
* event2; rRCORef event3; rRCORef event4; rRCORef event5; rRCORef event6;
- * rRCORef event7; rRCORef event8; uint32 unknown; // appears to be 0xFFFFFFFF
+ * rRCORef event7; rRCORef event8; uint32_t unknown; // appears to be 0xFFFFFFFF
* or 0 }); // 0x03 PACK_STRUCT(RCOObjSXmenu, { // only used for XMB menu?
- * RCOObjPos pos; uint32 unknown; rRCORef event1; rRCORef event2; rRCORef
+ * RCOObjPos pos; uint32_t unknown; rRCORef event1; rRCORef event2; rRCORef
* event3; rRCORef event4; rRCORef ref; }); // 0x04 PACK_STRUCT(RCOObjSXmList,
- * { // only used for XMB menu icons? uint32 unknown; // dunno if hex or float
+ * { // only used for XMB menu icons? uint32_t unknown; // dunno if hex or float
* rRCORef image; rRCORef ref; }); // 0x05 PACK_STRUCT(RCOObjSXList, {
- * RCOObjPos pos; uint32 unknown; rRCORef event1; rRCORef event2; rRCORef
+ * RCOObjPos pos; uint32_t unknown; rRCORef event1; rRCORef event2; rRCORef
* event3; rRCORef event4; rRCORef event5; rRCORef event6; rRCORef event7; });
- * // 0x06 PACK_STRUCT(RCOObjSProgress, { RCOObjPos pos; float unknown; uint32
+ * // 0x06 PACK_STRUCT(RCOObjSProgress, { RCOObjPos pos; float unknown; uint32_t
* unknown2; // dunno if hex or float rRCORef ref1; rRCORef ref2; rRCORef ref3;
* }); // 0x07 PACK_STRUCT(RCOObjSScroll, { // used for ilist? RCOObjPos pos;
- * float unknown; float unknown2; uint32 unknown3; // dunno if hex or float
+ * float unknown; float unknown2; uint32_t unknown3; // dunno if hex or float
* rRCORef ref1; rRCORef ref2; rRCORef ref3; rRCORef ref4; rRCORef ref5; }); //
* 0x08 PACK_STRUCT(RCOObjSMList, { // seems to be used for lists/menus
- * RCOObjPos pos; uint32 unknown; uint32 unknown2; // dunno if hex or float
- * uint32 unknown3; float unknown4; float unknown5; rRCORef ref1; rRCORef
+ * RCOObjPos pos; uint32_t unknown; uint32_t unknown2; // dunno if hex or float
+ * uint32_t unknown3; float unknown4; float unknown5; rRCORef ref1; rRCORef
* event1; rRCORef ref2; rRCORef ref3; rRCORef ref4; rRCORef event2; rRCORef
* ref5; rRCORef ref6; rRCORef ref7; rRCORef event3; rRCORef ref8; }); // 0x09
* PACK_STRUCT(RCOObjSMItem, { // menu item? rRCORef text; rRCORef textAlt;
* rRCORef ref; }); // 0x0A PACK_STRUCT(RCOObjSXItem, { rRCORef image; rRCORef
* text; rRCORef ref; }); // 0x0C PACK_STRUCT(RCOObjSText, { RCOObjPos pos;
- * rRCORef text; // the text displayed rRCORef ref1; uint32 unknownAlign; //
+ * rRCORef text; // the text displayed rRCORef ref1; uint32_t unknownAlign; //
* bottom byte: something to do with multiline text align; 1=left align,
- * 2=right, anything else=center uint32 unknown; float size; float topR; // top
+ * 2=right, anything else=center uint32_t unknown; float size; float topR; // top
* RGB values float topG; float topB; float bottomR; // bottom RGB values float
- * bottomG; float bottomB; float spacingHorizontal; uint32 unknown2; // dunno
- * whether hex or float uint32 unknown3; // dunno whether hex or float uint32
+ * bottomG; float bottomB; float spacingHorizontal; uint32_t unknown2; // dunno
+ * whether hex or float uint32_t unknown3; // dunno whether hex or float uint32_t
* unknown4; // dunno whether hex or float float spacingVertical; float shadowX;
* float shadowY; float shadowPerspective; // ? float shadowR; // ? float
- * shadowG; // ? float shadowB; // ? float shadowA; // ? uint32 unknown5; //
- * dunno whether hex or float uint32 unknown6; // dunno whether hex or float
- * uint32 unknown7; // dunno whether hex or float float unknown8; float unknown9;
- * float unknown10; float unknown11; uint32 unknown12; // dunno whether hex or
+ * shadowG; // ? float shadowB; // ? float shadowA; // ? uint32_t unknown5; //
+ * dunno whether hex or float uint32_t unknown6; // dunno whether hex or float
+ * uint32_t unknown7; // dunno whether hex or float float unknown8; float unknown9;
+ * float unknown10; float unknown11; uint32_t unknown12; // dunno whether hex or
* float? }); // 0x0D PACK_STRUCT(RCOObjSModel, { RCOObjPos pos; rRCORef model;
- * }); // 0x0E PACK_STRUCT(RCOObjSSpin, { RCOObjPos pos; uint32 unknown; // dunno
- * whether hex or float uint32 unknown2; rRCORef ref1; rRCORef ref2; rRCORef
+ * }); // 0x0E PACK_STRUCT(RCOObjSSpin, { RCOObjPos pos; uint32_t unknown; // dunno
+ * whether hex or float uint32_t unknown2; rRCORef ref1; rRCORef ref2; rRCORef
* event1; rRCORef event2; rRCORef event3; rRCORef ref3; rRCORef ref4; rRCORef
* ref5; rRCORef ref6; rRCORef ref7; }); // 0x0F PACK_STRUCT(RCOObjSAction, {
- * rRCORef ref; }); // 0x10 PACK_STRUCT(RCOObjSItemSpin, { RCOObjPos pos; uint32
- * unknown; uint32 unknown2; uint32 unknown3; uint32 unknown4; uint32 unknown5;
+ * rRCORef ref; }); // 0x10 PACK_STRUCT(RCOObjSItemSpin, { RCOObjPos pos; uint32_t
+ * unknown; uint32_t unknown2; uint32_t unknown3; uint32_t unknown4; uint32_t unknown5;
* float unknown6; rRCORef ref1; rRCORef ref2; rRCORef event1; rRCORef event2;
* rRCORef ref3; rRCORef ref4; rRCORef ref5; rRCORef ref6; rRCORef objPrev;
* rRCORef objNext; }); // 0x11 PACK_STRUCT(RCOObjSGroup, { RCOObjPos pos; }); //
- * 0x12 PACK_STRUCT(RCOObjSLList, { RCOObjPos pos; uint32 unknown; uint32
+ * 0x12 PACK_STRUCT(RCOObjSLList, { RCOObjPos pos; uint32_t unknown; uint32_t
* unknown2; // dunno whether hex or float float unknown3; rRCORef ref1; rRCORef
* ref2; rRCORef ref3; rRCORef ref4; rRCORef ref5; rRCORef ref6; rRCORef event;
* rRCORef ref7; }); // 0x13 PACK_STRUCT(RCOObjSLItem, { rRCORef text; rRCORef
* ref1; rRCORef ref2; }); // 0x14 PACK_STRUCT(RCOObjSEdit, { RCOObjPos pos;
- * uint32 unknown; // dunno whether hex or float uint32 unknown2; // dunno whether
- * hex or float uint32 unknown3; // dunno whether hex or float uint32 unknown4; //
+ * uint32_t unknown; // dunno whether hex or float uint32_t unknown2; // dunno whether
+ * hex or float uint32_t unknown3; // dunno whether hex or float uint32_t unknown4; //
* dunno whether hex or float rRCORef ref1; rRCORef ref2; rRCORef event1; rRCORef
* ref3; rRCORef ref4; rRCORef ref5; rRCORef event2; rRCORef event3; rRCORef obj1;
* rRCORef obj2; rRCORef ref6; }); // 0x15 PACK_STRUCT(RCOObjSClock, { RCOObjPos
- * pos; uint32 unknown; float unknown2; rRCORef text1; rRCORef text2; rRCORef ref1;
+ * pos; uint32_t unknown; float unknown2; rRCORef text1; rRCORef text2; rRCORef ref1;
* rRCORef ref2; rRCORef event1; rRCORef event2; rRCORef ref3; rRCORef ref4; rRCORef
* event3; rRCORef event4; rRCORef ref5; rRCORef ref6; rRCORef event5; }); // 0x16
* PACK_STRUCT(RCOObjSIList, { RCOObjPos pos; float unknown; rRCORef ref1; rRCORef
* PACK_STRUCT(RCOObjSUButton, { RCOObjPos pos; rRCORef img1; rRCORef event1; //
* onPush rRCORef event2; // onFocusIn rRCORef event3; // [event/anim] onFocusOut
* rRCORef ref1; // [object/event] rRCORef ref2; // [object/event] rRCORef ref3; //
- * [object/event] prev/up? rRCORef ref4; // [object/event] next/down? uint32
+ * [object/event] prev/up? rRCORef ref4; // [object/event] next/down? uint32_t
* unknown; // 0xFFFFFFFF or 0 }); // 0x1A
*
- * PACK_STRUCT(RCOAnimSPos, { rRCORef obj; float time; uint32 unknown; float x;
+ * PACK_STRUCT(RCOAnimSPos, { rRCORef obj; float time; uint32_t unknown; float x;
* float y; float unknown2; }); PACK_STRUCT(RCOAnimSColour, { rRCORef obj; float
- * time; uint32 unknown; // dunno whether float or int (probably int) float r; float
+ * time; uint32_t unknown; // dunno whether float or int (probably int) float r; float
* g; float b; float a; }); PACK_STRUCT(RCOAnimSRotate, { // TODO: this one needs
- * checking rRCORef obj; float time; uint32 unknown; // dunno whether float or int
- * (probably int) uint32 unknown2; // dunno whether float or int (probably int)
- * uint32 unknown3; // dunno whether float or int (probably int) uint32 rotation;
- * }); PACK_STRUCT(RCOAnimSScale, { rRCORef obj; float time; uint32 unknown; float
+ * checking rRCORef obj; float time; uint32_t unknown; // dunno whether float or int
+ * (probably int) uint32_t unknown2; // dunno whether float or int (probably int)
+ * uint32_t unknown3; // dunno whether float or int (probably int) uint32_t rotation;
+ * }); PACK_STRUCT(RCOAnimSScale, { rRCORef obj; float time; uint32_t unknown; float
* w; float h; float unknown2; }); PACK_STRUCT(RCOAnimSAlpha, { rRCORef obj; float
- * time; uint32 unknown; float a; }); PACK_STRUCT(RCOAnimSDelay, { float time; });
+ * time; uint32_t unknown; float a; }); PACK_STRUCT(RCOAnimSDelay, { float time; });
* PACK_STRUCT(RCOAnimSEvent, { rRCORef event; }); PACK_STRUCT(RCOAnimSLock, {
- * uint32 unknown; // always seems to be 0xFFFFFFFF }); PACK_STRUCT(RCOAnimSUnlock,
- * { uint32 unknown; // always seems to be 0xFFFFFFFF });
- * PACK_STRUCT(RCOAnimSSlideout, { rRCORef obj; uint32 unknown; uint32 unknown2;
- * float unknown3; uint32 unknown4; uint32 unknown5; float unknown6; }); */
+ * uint32_t unknown; // always seems to be 0xFFFFFFFF }); PACK_STRUCT(RCOAnimSUnlock,
+ * { uint32_t unknown; // always seems to be 0xFFFFFFFF });
+ * PACK_STRUCT(RCOAnimSSlideout, { rRCORef obj; uint32_t unknown; uint32_t unknown2;
+ * float unknown3; uint32_t unknown4; uint32_t unknown5; float unknown6; }); */
#endif
// items used only when reading the file
typedef struct {
char *fName;
- uint fSize;
- uint fSizeExpanded; // file size with decompressed header
+ uint32_t fSize;
+ uint32_t fSizeExpanded; // file size with decompressed header
void *tables; // decompressed tables
- uint tablesSize;
- uint memPos;
- uint memOffset;
+ uint32_t tablesSize;
+ uint32_t memPos;
+ uint32_t memOffset;
FILE *fp; // for uncompressed tables
- uint32 *ptrsObj;
- uint numObjPtrs;
- uint32 *ptrsAnim;
- uint numAnimPtrs;
+ uint32_t *ptrsObj;
+ uint32_t numObjPtrs;
+ uint32_t *ptrsAnim;
+ uint32_t numAnimPtrs;
- Bool ps3; // TRUE if PS3 RCO
+ uint8_t ps3; // TRUE if PS3 RCO
} rRCOFile_readhelper;
void read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data,
- Bool readSubEntries);
-rRCOEntry *find_entry_from_offset (rRCOEntry * parent, uint32 offset);
-Bool check_file_region (uint fSize, uint offset, uint size);
-uint rco_fread (rRCOFile_readhelper * rcoH, void *buf, uint len);
-uint rcoread_ftell (rRCOFile_readhelper * rcoH);
-int rcoread_fseek (rRCOFile_readhelper * rcoH, uint pos);
+ uint8_t readSubEntries);
+rRCOEntry *find_entry_from_offset (rRCOEntry * parent, uint32_t offset);
+uint8_t check_file_region (uint32_t fSize, uint32_t offset, uint32_t size);
+uint32_t rco_fread (rRCOFile_readhelper * rcoH, void *buf, uint32_t len);
+uint32_t rcoread_ftell (rRCOFile_readhelper * rcoH);
+int rcoread_fseek (rRCOFile_readhelper * rcoH, uint32_t pos);
void fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray,
- const uint lenNum, Bool isObj);
+ const uint32_t lenNum, uint8_t isObj);
rRCOFile *
read_rco (char *fn)
error ("[text-data] Size of text data exceeds sane limits.");
return NULL;
}
- uint oldSize = rcoH.tablesSize;
+ uint32_t oldSize = rcoH.tablesSize;
rcoH.tablesSize += ALIGN_TO_4 (tci.unpackedLen);
rcoH.tables = realloc (rcoH.tables, rcoH.tablesSize);
warning("[%s] Total data length (%d) exceeds safety limit of 16MB - data has been truncated!", s, hl); \
hl = MAX_LABEL_DATA; \
} \
- dl = (hl) / sizeof(uint32); \
- hl = (dl) * sizeof(uint32); \
+ dl = (hl) / sizeof(uint32_t); \
+ hl = (dl) * sizeof(uint32_t); \
if(dl) { \
- dp = (uint32*)malloc(hl); \
+ dp = (uint32_t*)malloc(hl); \
rcoread_fseek(&rcoH, hp); \
rco_fread(&rcoH, dp, hl); \
} \
void
read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data,
- Bool readSubEntries)
+ uint8_t readSubEntries)
{
data->offset = rcoread_ftell (rcoH);
data->extra = 0;
data->srcBuffer = NULL;
// data->extraSize = 0;
- uint extraSize = 0;
+ uint32_t extraSize = 0;
{
// cbf checking for file exhaustion here - just let read calls fail
data->offset, ((rRCOTextEntry *) data->extra)->numIndexes);
dest->numIndexes = MAX_SUBENTRIES;
}
- uint readAmt = dest->numIndexes * sizeof (RCOTextIndex);
+ uint32_t readAmt = dest->numIndexes * sizeof (RCOTextIndex);
extraSize = sizeof (RCOTextEntry) + readAmt;
dest->indexes = (RCOTextIndex *) malloc (readAmt);
return;
}
if (rco->eSwap) { // endian swap all indexes
- uint i;
+ uint32_t i;
for (i = 0; i < dest->numIndexes; i++)
es_rcoTextIndex (dest->indexes + i);
case RCO_TABLE_MODEL:
if (data->type == 1) {
RCOImgModelEntry rie;
- uint rimeSize =
+ uint32_t rimeSize =
(rco->
ps3 ? sizeof (RCOPS3ImgModelEntry) : sizeof (RCOImgModelEntry));
- uint16 compression;
+ uint16_t compression;
extraSize = rimeSize;
// urgh, this is a bit of an ugly hack - these short entries are
// something I didn't know about before :/
- if (rco_fread (rcoH, &rie, sizeof (uint32))) {
+ if (rco_fread (rcoH, &rie, sizeof (uint32_t))) {
compression = rie.compression;
if (rco->eSwap)
compression = ENDIAN_SWAP (compression);
// image entry)
if (!re.nextEntryOffset ||
re.nextEntryOffset < sizeof (RCOEntry) + rimeSize)
- extraSize -= sizeof (uint32);
+ extraSize -= sizeof (uint32_t);
}
} else {
error
}
if (rco->ps3) {
- if (!rco_fread (rcoH, (uint8 *) (&rie) + sizeof (uint32),
- sizeof (uint32) * 3)) {
+ if (!rco_fread (rcoH, (uint8_t *) (&rie) + sizeof (uint32_t),
+ sizeof (uint32_t) * 3)) {
error
("[entry (0x%x)] Unable to read entry extra data - file exhausted.",
data->offset);
data->offset, ENDIAN_SWAP (rie.sizeUnpacked));
rie.sizeUnpacked = rie.sizePacked;
if (compression) {
- rco_fread (rcoH, &rie.sizeUnpacked, sizeof (uint32));
+ rco_fread (rcoH, &rie.sizeUnpacked, sizeof (uint32_t));
}
- } else if (!rco_fread (rcoH, (uint8 *) (&rie) + sizeof (uint32),
- extraSize - sizeof (uint32))) {
+ } else if (!rco_fread (rcoH, (uint8_t *) (&rie) + sizeof (uint32_t),
+ extraSize - sizeof (uint32_t))) {
error
("[entry (0x%x)] Unable to read entry extra data - file exhausted.",
data->offset);
/*
* // dirty hack for reading PS3 stuff if(rco->ps3 && extraSize ==
- * rimeSize) extraSize -= sizeof(uint32);
+ * rimeSize) extraSize -= sizeof(uint32_t);
*
- * if(!rco_fread(rcoH, (uint8*)(&rie) +sizeof(uint32), extraSize -
- * sizeof(uint32))) { error("[entry (0x%x)] Unable to read entry
+ * if(!rco_fread(rcoH, (uint8_t*)(&rie) +sizeof(uint32_t), extraSize -
+ * sizeof(uint32_t))) { error("[entry (0x%x)] Unable to read entry
* extra data - file exhausted.", data->offset); return; }
* if(rco->ps3 && rie.sizeUnpacked != ENDIAN_SWAP_32(1))
* warning("[entry (0x%x)] Unexpected value 0x%x for PS3 image -
* expected 0x1.", data->offset, ENDIAN_SWAP(rie.sizeUnpacked));
- * if(rco->ps3 && compression && extraSize + sizeof(uint32) ==
- * rimeSize) { extraSize += sizeof(uint32); rco_fread(rcoH,
- * &rie.sizeUnpacked, sizeof(uint32)); // TODO: (fix this?) ignore
+ * if(rco->ps3 && compression && extraSize + sizeof(uint32_t) ==
+ * rimeSize) { extraSize += sizeof(uint32_t); rco_fread(rcoH,
+ * &rie.sizeUnpacked, sizeof(uint32_t)); // TODO: (fix this?) ignore
* the weird unknown entry for now } */
if (rco->eSwap)
es_rcoImgModelEntry (&rie);
((rRCOSoundEntry *) data->extra)->format = rse.format;
((rRCOSoundEntry *) data->extra)->channels = rse.channels;
// alloc & read channels (max = 65535, so don't bother checking)
- uint readAmt = rse.channels * 2 * sizeof (uint32);
+ uint32_t readAmt = rse.channels * 2 * sizeof (uint32_t);
extraSize = sizeof (RCOSoundEntry) + readAmt;
((rRCOSoundEntry *) data->extra)->channelData =
- (uint32 *) malloc (readAmt);
+ (uint32_t *) malloc (readAmt);
if (!rco_fread (rcoH, ((rRCOSoundEntry *) data->extra)->channelData,
readAmt)) {
error
data->offset);
return;
}
- uint i;
+ uint32_t i;
if (rco->eSwap) {
- uint32 *cd = ((rRCOSoundEntry *) data->extra)->channelData;
+ uint32_t *cd = ((rRCOSoundEntry *) data->extra)->channelData;
- for (i = 0; i < (uint) rse.channels * 2; i++)
+ for (i = 0; i < (uint32_t) rse.channels * 2; i++)
cd[i] = ENDIAN_SWAP (cd[i]);
}
// make offsets relative
// defined (no clear indication of size otherwise)
for (i = rse.channels; i < 2; i++) {
struct {
- uint32 size;
- uint32 offset;
+ uint32_t size;
+ uint32_t offset;
} p;
// not sure if there's padding, so just read things one by one
- rco_fread (rcoH, &(p.size), sizeof (uint32));
- rco_fread (rcoH, &(p.offset), sizeof (uint32));
+ rco_fread (rcoH, &(p.size), sizeof (uint32_t));
+ rco_fread (rcoH, &(p.offset), sizeof (uint32_t));
if (p.size || p.offset != RCO_NULL_PTR)
warning
("[entry (0x%x)] Unexpected values found in sound entry data where null channels were expected.",
data->offset);
- extraSize += sizeof (uint32) * 2;
+ extraSize += sizeof (uint32_t) * 2;
}
}
} else if (data->type != 0)
case RCO_TABLE_OBJ:
if (data->type > 0) {
- uint entrySize = 0;
+ uint32_t entrySize = 0;
// determine size of entry from object type
if (data->type <= (int) RCO_OBJ_EXTRA_LEN_NUM &&
case RCO_TABLE_ANIM:
if (data->type > 1) {
- uint entrySize = 0;
+ uint32_t entrySize = 0;
// determine size of entry from anim type
if (data->type <= RCO_ANIM_EXTRA_LEN_NUM &&
// process subentries
if (readSubEntries && data->numSubentries) {
- uint i;
+ uint32_t i;
if (data->numSubentries > MAX_SUBENTRIES) {
warning
data->numSubentries = MAX_SUBENTRIES;
}
- uint curFPos = data->offset + sizeof (re) + extraSize;
+ uint32_t curFPos = data->offset + sizeof (re) + extraSize;
rRCOEntry *rcoNode = (rRCOEntry *) malloc (sizeof (rRCOEntry));
data->firstChild = rcoNode;
// linear/recursive search - not the fastest, but eh, performance isn't that
// much of an issue
rRCOEntry *
-find_entry_from_offset (rRCOEntry * parent, uint32 offset)
+find_entry_from_offset (rRCOEntry * parent, uint32_t offset)
{
if (parent->offset == offset)
return parent;
void
fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray,
- const uint lenNum, Bool isObj)
+ const uint32_t lenNum, uint8_t isObj)
{
- uint i, i2;
+ uint32_t i, i2;
// only fix refs if type is known, and not the main object(0x800)/anim(0x900)
// table
if (entry->type != 0 && entry->type <= (int) lenNum &&
lenArray[entry->type] != -1) {
- uint destSize = lenArray[entry->type] * sizeof (uint32);
+ uint32_t destSize = lenArray[entry->type] * sizeof (uint32_t);
if (isObj) {
- for (i = 0, i2 = 0; i < (uint) RCO_OBJ_EXTRA_LEN[entry->type]; i++, i2++)
+ for (i = 0, i2 = 0; i < (uint32_t) RCO_OBJ_EXTRA_LEN[entry->type]; i++, i2++)
if (RCO_OBJ_IS_REF (entry->type, i2)) {
- destSize -= sizeof (uint32) * 2; // size of ref source
+ destSize -= sizeof (uint32_t) * 2; // size of ref source
destSize += sizeof (rRCORef);
i++;
}
} else {
- /* if(RCO_ANIM_EXTRA_REFS[entry->type]) { destSize -= sizeof(uint32)*2;
+ /* if(RCO_ANIM_EXTRA_REFS[entry->type]) { destSize -= sizeof(uint32_t)*2;
* // size of ref source destSize += sizeof(rRCORef); } */
- for (i = 0, i2 = 0; i < (uint) RCO_ANIM_EXTRA_LEN[entry->type]; i++, i2++)
+ for (i = 0, i2 = 0; i < (uint32_t) RCO_ANIM_EXTRA_LEN[entry->type]; i++, i2++)
if (RCO_ANIM_IS_REF (entry->type, i2)) {
- destSize -= sizeof (uint32) * 2; // size of ref source
+ destSize -= sizeof (uint32_t) * 2; // size of ref source
destSize += sizeof (rRCORef);
i++;
}
}
void *dest = malloc (destSize);
- uint8 *destPtr = (uint8 *) dest;
+ uint8_t *destPtr = (uint8_t *) dest;
- for (i = 0, i2 = 0; i < (uint) lenArray[entry->type]; i++, i2++) {
- Bool cond;
+ for (i = 0, i2 = 0; i < (uint32_t) lenArray[entry->type]; i++, i2++) {
+ uint8_t cond;
if (isObj)
cond = (RCO_OBJ_IS_REF (entry->type, i2));
cond = (RCO_ANIM_IS_REF (entry->type, i2));
// cond = (RCO_ANIM_EXTRA_REFS[entry->type] && i == 0);
if (cond) {
- RCOReference *ref = (RCOReference *) ((uint8 *) entry->extra + i * 4);
+ RCOReference *ref = (RCOReference *) ((uint8_t *) entry->extra + i * 4);
rRCORef *newRef = (rRCORef *) destPtr;
newRef->type = ref->type;
i++;
destPtr += sizeof (rRCORef);
} else {
- *(uint32 *) destPtr = *(uint32 *) ((uint8 *) entry->extra + i * 4);
- destPtr += sizeof (uint32);
+ *(uint32_t *) destPtr = *(uint32_t *) ((uint8_t *) entry->extra + i * 4);
+ destPtr += sizeof (uint32_t);
}
}
fix_refs (rco, rcoNode, lenArray, lenNum, isObj);
}
-Bool
-check_file_region (uint fSize, uint offset, uint size)
+uint8_t
+check_file_region (uint32_t fSize, uint32_t offset, uint32_t size)
{
if (offset + size > fSize)
return FALSE;
}
// wrapper file functions, but can read from memory
-uint
-rco_fread (rRCOFile_readhelper * rcoH, void *buf, uint len)
+uint32_t
+rco_fread (rRCOFile_readhelper * rcoH, void *buf, uint32_t len)
{
if (rcoH->tablesSize) {
if (rcoH->memPos + len > rcoH->tablesSize)
len = rcoH->tablesSize - rcoH->memPos;
- memcpy (buf, ((uint8 *) rcoH->tables) + rcoH->memPos, len);
+ memcpy (buf, ((uint8_t *) rcoH->tables) + rcoH->memPos, len);
rcoH->memPos += len;
return len;
}
}
-uint
+uint32_t
rcoread_ftell (rRCOFile_readhelper * rcoH)
{
if (rcoH->tablesSize) {
}
int
-rcoread_fseek (rRCOFile_readhelper * rcoH, uint pos)
+rcoread_fseek (rRCOFile_readhelper * rcoH, uint32_t pos)
{
if (rcoH->tablesSize) {
if (pos < rcoH->memOffset || pos - rcoH->memOffset > rcoH->tablesSize)
rRCOFile *rco;
// tracking size of resources
- uint32 sizeImg, sizeModel, sizeSound;
- uint32 sizeText;
+ uint32_t sizeImg, sizeModel, sizeSound;
+ uint32_t sizeText;
- uint32 longestLangData; // just for keeping track for text compression
+ uint32_t longestLangData; // just for keeping track for text compression
// memory compression thing
void *tables;
- uint tablesSize;
- uint tablesBuffered; // internal value used for buffering, following
+ uint32_t tablesSize;
+ uint32_t tablesBuffered; // internal value used for buffering, following
// define is the amount to increase the buffer
// by when necessary
#define RCO_WRITE_MEM_BUFFER 65536
- uint memPos;
- uint memOffset; // should always be 0xA4
+ uint32_t memPos;
+ uint32_t memOffset; // should always be 0xA4
} rRCOFile_writehelper;
-uint write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
- uint parentOffset, uint prevOffset, Bool isLastSubentry);
-uint rcowrite_ftell (rRCOFile_writehelper * rcoH);
-void rco_fwrite (rRCOFile_writehelper * rcoH, void *buffer, uint len);
-void rcowrite_fseek (rRCOFile_writehelper * rcoH, uint pos);
+uint32_t write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
+ uint32_t parentOffset, uint32_t prevOffset, uint8_t isLastSubentry);
+uint32_t rcowrite_ftell (rRCOFile_writehelper * rcoH);
+void rco_fwrite (rRCOFile_writehelper * rcoH, void *buffer, uint32_t len);
+void rcowrite_fseek (rRCOFile_writehelper * rcoH, uint32_t pos);
-uint rco_write_resource (FILE * dest, rRCOEntry * entry, uint destCompression,
+uint32_t rco_write_resource (FILE * dest, rRCOEntry * entry, uint32_t destCompression,
writerco_options * opts, rRCOFile * rco);
-uint rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
- uint destCompression, writerco_options * opts, uint lang, Bool isLast);
+uint32_t rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
+ uint32_t destCompression, writerco_options * opts, uint32_t lang, uint8_t isLast);
void rco_write_fix_refs (rRCOEntry * parent, rRCOFile_writehelper * rcoH,
- rRCOFile * rco, const int *lenArray, const int lenNum, Bool isObj);
+ rRCOFile * rco, const int *lenArray, const int lenNum, uint8_t isObj);
-uint write_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
+uint32_t write_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
rRCOFile * rco);
-uint write_text_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
+uint32_t write_text_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
rRCOFile * rco);
-void do_hashing (rRCOEntry * entry, rRCOFile * rco, Bool recurse,
- uint32 * hashTable, uint hashTableSize);
-uint calc_hash (char *in, uint32 * hashTable, uint hashTableSize);
+void do_hashing (rRCOEntry * entry, rRCOFile * rco, uint8_t recurse,
+ uint32_t * hashTable, uint32_t hashTableSize);
+uint32_t calc_hash (char *in, uint32_t * hashTable, uint32_t hashTableSize);
int text_hash_table_qsort (const rRCOEntry ** a, const rRCOEntry ** b);
// packing: use RCO_DATA_COMPRESSION_* constants
-Bool
+uint8_t
write_rco (rRCOFile * rco, char *fn, writerco_options opts)
{
- uint i;
+ uint32_t i;
rRCOFile_writehelper rcoH;
// delete file if exists
if ((rco->tblImage && rco->tblImage->numSubentries)
|| (rco->tblSound && rco->tblSound->numSubentries)
|| (rco->tblModel && rco->tblModel->numSubentries)) {
- uint32 totalPackedLen = 0;
+ uint32_t totalPackedLen = 0;
rRCOEntry *rcoNode;
fTmp = tmpfile ();
for (rcoNode = rco->tblImage->firstChild; rcoNode;
rcoNode = rcoNode->next) {
// our compression decision thing
- uint c = ((rRCOImgModelEntry *) (rcoNode->extra))->compression;
+ uint32_t c = ((rRCOImgModelEntry *) (rcoNode->extra))->compression;
if (((rRCOImgModelEntry *) (rcoNode->extra))->format < RCO_IMG_BMP) {
if (opts.packImgCompr != -1)
for (rcoNode = rco->tblSound->firstChild; rcoNode;
rcoNode = rcoNode->next) {
if (rcoNode->srcLenUnpacked) {
- uint packedLen = rco_write_resource (fTmp, rcoNode,
+ uint32_t packedLen = rco_write_resource (fTmp, rcoNode,
RCO_DATA_COMPRESSION_NONE,
&opts,
rco);
if (rco->tblModel && rco->tblModel->numSubentries) {
for (rcoNode = rco->tblModel->firstChild; rcoNode;
rcoNode = rcoNode->next) {
- uint c = ((rRCOImgModelEntry *) (rcoNode->extra))->compression;
+ uint32_t c = ((rRCOImgModelEntry *) (rcoNode->extra))->compression;
if (opts.packModel != -1)
c = opts.packModel;
{ // write hashtable data
/* { // special case for text hashes if(rco->numPtrText) { header.pTextPtrs
- * = rcowrite_ftell(&rcoH); for(i=0; i<rco->numPtrText; i++) { uint32
+ * = rcowrite_ftell(&rcoH); for(i=0; i<rco->numPtrText; i++) { uint32_t
* writePtr = 0; if(rco->ptrText[i].textEntry && rco->ptrText[i].index)
* writePtr = rco->ptrText[i].textEntry->offset + sizeof(RCOEntry) +
* sizeof(RCOTextEntry) + (rco->ptrText[i].index -
* ((rRCOTextEntry*)(rco->ptrText[i].textEntry->extra))->indexes)*sizeof(RCOTextIndex);
- * rco_fwrite(&rcoH, &writePtr, sizeof(uint32)); } } } */
+ * rco_fwrite(&rcoH, &writePtr, sizeof(uint32_t)); } } } */
if (rco->tblText) {
header.pTextPtrs = rcowrite_ftell (&rcoH);
header.lTextPtrs = 0;
header.lTextPtrs += write_text_hash_table (&rcoH, sList[i], rco);
free (sList);
- header.lTextPtrs *= sizeof (uint32);
+ header.lTextPtrs *= sizeof (uint32_t);
}
if (rco->tblImage) {
header.pImgPtrs = rcowrite_ftell (&rcoH);
header.lImgPtrs =
- write_hash_table (&rcoH, rco->tblImage, rco) * sizeof (uint32);
+ write_hash_table (&rcoH, rco->tblImage, rco) * sizeof (uint32_t);
}
if (rco->tblModel) {
header.pModelPtrs = rcowrite_ftell (&rcoH);
header.lModelPtrs =
- write_hash_table (&rcoH, rco->tblModel, rco) * sizeof (uint32);
+ write_hash_table (&rcoH, rco->tblModel, rco) * sizeof (uint32_t);
}
if (rco->tblSound) {
header.pSoundPtrs = rcowrite_ftell (&rcoH);
header.lSoundPtrs =
- write_hash_table (&rcoH, rco->tblSound, rco) * sizeof (uint32);
+ write_hash_table (&rcoH, rco->tblSound, rco) * sizeof (uint32_t);
}
if (rco->tblObj) {
header.pObjPtrs = rcowrite_ftell (&rcoH);
header.lObjPtrs =
- write_hash_table (&rcoH, rco->tblObj, rco) * sizeof (uint32);
+ write_hash_table (&rcoH, rco->tblObj, rco) * sizeof (uint32_t);
}
if (rco->tblAnim) {
header.pAnimPtrs = rcowrite_ftell (&rcoH);
header.lAnimPtrs =
- write_hash_table (&rcoH, rco->tblAnim, rco) * sizeof (uint32);
+ write_hash_table (&rcoH, rco->tblAnim, rco) * sizeof (uint32_t);
}
/*
* #define RCO_WRITERCO_WRITE_PTR_SECT(pd, pl, hp) { \ if(pl) { \ hp =
* rcowrite_ftell(&rcoH); \ for(i=0; i<pl; i++) { \ if(pd[i]) \
- * rco_fwrite(&rcoH, &(((rRCOEntry*)(pd[i]))->offset), sizeof(uint32)); \
- * else { \ uint32 zero = 0; \ rco_fwrite(&rcoH, &zero, sizeof(uint32)); \
+ * rco_fwrite(&rcoH, &(((rRCOEntry*)(pd[i]))->offset), sizeof(uint32_t)); \
+ * else { \ uint32_t zero = 0; \ rco_fwrite(&rcoH, &zero, sizeof(uint32_t)); \
* } \ } \ } \ } //RCO_WRITERCO_WRITE_PTR_SECT(rco->ptrText,
* rco->numPtrText, header.pTextPtrs);
* RCO_WRITERCO_WRITE_PTR_SECT(rco->ptrImg, rco->numPtrImg,
// well (although there isn't
// an RCO with anim that
// doesn't have objects)
- uint32 zero = 0;
+ uint32_t zero = 0;
rco_fwrite (&rcoH, &zero, sizeof (zero));
header.lEventData = sizeof (zero);
HeaderComprInfo ci;
if (opts.packHeader) {
- uint8 *bufferOut = NULL;
+ uint8_t *bufferOut = NULL;
ci.lenLongestText = rcoH.longestLangData;
ci.lenUnpacked = rcoH.tablesSize;
ci.lenPacked = 0;
if (opts.packHeader == RCO_DATA_COMPRESSION_ZLIB) {
- uint bound = compressBound (rcoH.tablesSize);
+ uint32_t bound = compressBound (rcoH.tablesSize);
- bufferOut = (uint8 *) malloc (bound);
+ bufferOut = (uint8_t *) malloc (bound);
ci.lenPacked =
zlib_compress (rcoH.tables, rcoH.tablesSize, bufferOut, bound,
opts.zlibLevel, opts.zlibMethod);
} else if (opts.packHeader == RCO_DATA_COMPRESSION_RLZ) {
- bufferOut = (uint8 *) malloc (rcoH.tablesSize);
+ bufferOut = (uint8_t *) malloc (rcoH.tablesSize);
ci.lenPacked =
rlz_compress (rcoH.tables, rcoH.tablesSize, bufferOut,
rcoH.tablesSize, opts.rlzMode);
exit (1);
}
int comprMisalign = ci.lenPacked % 4;
- uint packedLen = ci.lenPacked;
+ uint32_t packedLen = ci.lenPacked;
if (rco->eSwap)
es_headerComprInfo (&ci);
free (bufferOut);
if (comprMisalign) { // 4 byte align
- uint32 zero = 0;
+ uint32_t zero = 0;
filewrite (rcoH.fp, &zero, 4 - comprMisalign);
}
}
}
// write resources
- /* { uint32 totalPackedLen = 0; if(rco->tblImage) { header.pImgData =
+ /* { uint32_t totalPackedLen = 0; if(rco->tblImage) { header.pImgData =
* rcowrite_ftell(&rcoH); header.lImgData = rcoH.sizeImg; // TOxDO: this
* model actually won't work - we have to update the offsets of ALL the
* entries after packing... for(i=0; i<rco->tblImage->numSubentries; i++) {
- * uint32 packedSize = rco_write_resource(&rcoH,
+ * uint32_t packedSize = rco_write_resource(&rcoH,
* &(rco->tblImage->subentries[i]), RCO_DATA_COMPRESSION_NONE); // TOxDO:
- * change this // TOxDO: update packed size value uint curFpos =
+ * change this // TOxDO: update packed size value uint32_t curFpos =
* rcowrite_ftell(rcoH.fp);
*
* totalPackedLen += (packedSize % 4 ? (packedSize/4)*4+4 : packedSize); }
|| (rco->tblSound && rco->tblSound->numSubentries)
|| (rco->tblModel && rco->tblModel->numSubentries)) {
// update data pointers
- uint32 pos = ftell (rcoH.fp);
+ uint32_t pos = ftell (rcoH.fp);
if (rco->tblImage && rco->tblImage->numSubentries) {
header.pImgData = pos;
pos += header.lModelData;
}
// copy contents of fTmp across (uses a simple buffered copy)
- uint len = header.lImgData + header.lSoundData + header.lModelData;
- uint8 buffer[65536];
+ uint32_t len = header.lImgData + header.lSoundData + header.lModelData;
+ uint8_t buffer[65536];
while (len) {
- uint readAmt = (len > 65536 ? 65536 : len);
+ uint32_t readAmt = (len > 65536 ? 65536 : len);
fileread (fTmp, buffer, readAmt);
filewrite (rcoH.fp, buffer, readAmt);
// returns next entry offset (like the length, but the last entry returns zero)
// - doesn't really have much meaning - it's primarily used for internal
// purposes
-uint
-write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset,
- uint prevOffset, Bool isLastSubentry)
+uint32_t
+write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint32_t parentOffset,
+ uint32_t prevOffset, uint8_t isLastSubentry)
{
- uint fPos = rcowrite_ftell (rcoH);
+ uint32_t fPos = rcowrite_ftell (rcoH);
entry->offset = fPos;
RCOEntry re;
(entry->id == RCO_TABLE_OBJ ? RCO_OBJ_EXTRA_LEN : RCO_ANIM_EXTRA_LEN);
if (entry->type <= lenNum && lenArray[entry->type] > 0)
re.entrySize =
- sizeof (RCOEntry) + lenArray[entry->type] * sizeof (uint32);
+ sizeof (RCOEntry) + lenArray[entry->type] * sizeof (uint32_t);
}
re.prevEntryOffset = prevOffset;
es_rcoVsmxEntry (&rve);
rco_fwrite (rcoH, &rve, sizeof (rve));
- uint vsmxLen = 0;
- uint8 *bufferVSMX = (uint8 *) read_resource (entry, &vsmxLen);
+ uint32_t vsmxLen = 0;
+ uint8_t *bufferVSMX = (uint8_t *) read_resource (entry, &vsmxLen);
if (bufferVSMX) {
if (vsmxLen == entry->srcLenUnpacked)
if (entry->type == 1) {
RCOTextEntry rte;
rRCOTextEntry *src = (rRCOTextEntry *) entry->extra;
- uint i;
+ uint32_t i;
rte.lang = src->lang;
rte.format = src->format;
// instead of blindly dumping src->indexes, we'll "pack" the entries
// together (allows source file to be of a different format, ie INI)
- uint32 entryTextOffset = rcoH->sizeText;
+ uint32_t entryTextOffset = rcoH->sizeText;
for (i = 0; i < src->numIndexes; i++) {
RCOTextIndex rti;
if (entry->type == 1) {
rRCOImgModelEntry *srcExtra = (rRCOImgModelEntry *) entry->extra;
RCOImgModelEntry rie;
- uint32 *totalResSize =
+ uint32_t *totalResSize =
(entry->id ==
RCO_TABLE_IMG ? &(rcoH->sizeImg) : &(rcoH->sizeModel));
rie.format = srcExtra->format;
// we'll omit the packed length value if this is an uncompressed entry
if (entry->rco->ps3) { // PS3 image quirk
- uint32 one = ENDIAN_SWAP (1);
+ uint32_t one = ENDIAN_SWAP (1);
- rco_fwrite (rcoH, &rie, sizeof (rie) - sizeof (uint32));
+ rco_fwrite (rcoH, &rie, sizeof (rie) - sizeof (uint32_t));
rco_fwrite (rcoH, &one, sizeof (one));
if (entry->srcCompression != RCO_DATA_COMPRESSION_NONE)
rco_fwrite (rcoH, &rie.sizeUnpacked, sizeof (rie.sizeUnpacked));
} else {
rco_fwrite (rcoH, &rie,
sizeof (rie) - (entry->srcCompression ==
- RCO_DATA_COMPRESSION_NONE ? sizeof (uint32) : 0));
+ RCO_DATA_COMPRESSION_NONE ? sizeof (uint32_t) : 0));
}
}
break;
if (entry->type != 0) {
rRCOSoundEntry *srcExtra = (rRCOSoundEntry *) entry->extra;
RCOSoundEntry rse;
- uint rseOffset;
+ uint32_t rseOffset;
rse.format = srcExtra->format;
rseOffset = rse.offset = rcoH->sizeSound;
rco_fwrite (rcoH, &rse, sizeof (rse));
// write size/offset pairs
- uint i;
+ uint32_t i;
// TODO: might actually restrict this to two channels later on
for (i = 0; i < srcExtra->channels; i++) {
- uint32 stuffToWrite[] = { srcExtra->channelData[i * 2],
+ uint32_t stuffToWrite[] = { srcExtra->channelData[i * 2],
srcExtra->channelData[i * 2 + 1] + rseOffset
};
if (entry->rco->eSwap) {
if (srcExtra->channels < 2) {
// we'll write an extra blank channel, complying with how Sony's RCO
// tools work
- uint32 stuffToWrite[] = { 0, RCO_NULL_PTR };
- uint i;
+ uint32_t stuffToWrite[] = { 0, RCO_NULL_PTR };
+ uint32_t i;
// actually, the following is unnecessary, but we'll keep it here for
// reference sake
stuffToWrite[1] = ENDIAN_SWAP (stuffToWrite[1]);
}
for (i = srcExtra->channels; i < 2; i++)
- rco_fwrite (rcoH, &stuffToWrite, sizeof (uint32) * 2);
+ rco_fwrite (rcoH, &stuffToWrite, sizeof (uint32_t) * 2);
}
}
break;
RCO_TABLE_OBJ ? RCO_OBJ_EXTRA_LEN : RCO_ANIM_EXTRA_LEN);
// just allocate space because we need to fix this later on
if (entry->type <= lenNum && lenArray[entry->type] > 0) {
- uint32 anAwesomeVariable = lenArray[entry->type];
+ uint32_t anAwesomeVariable = lenArray[entry->type];
while (anAwesomeVariable--)
rco_fwrite (rcoH, &anAwesomeVariable, sizeof (anAwesomeVariable));
}
// subentries
- uint nextOffset = 0;
+ uint32_t nextOffset = 0;
rRCOEntry *rcoNode;
for (rcoNode = entry->firstChild; rcoNode; rcoNode = rcoNode->next) {
// write nextEntryOffset
if (!isLastSubentry) {
- uint curPos = rcowrite_ftell (rcoH);
+ uint32_t curPos = rcowrite_ftell (rcoH);
re.nextEntryOffset = curPos - fPos;
rcowrite_fseek (rcoH, fPos);
}
void
-rco_fwrite (rRCOFile_writehelper * rcoH, void *buffer, uint len)
+rco_fwrite (rRCOFile_writehelper * rcoH, void *buffer, uint32_t len)
{
// memory writing
if (rcoH->tables) {
- uint len4 = ALIGN_TO_4 (len);
+ uint32_t len4 = ALIGN_TO_4 (len);
if (rcoH->memPos + len4 > rcoH->tablesBuffered) {
rcoH->tablesBuffered = rcoH->memPos + len4 + RCO_WRITE_MEM_BUFFER;
rcoH->tables = realloc (rcoH->tables, rcoH->tablesBuffered);
}
- memcpy ((uint8 *) rcoH->tables + rcoH->memPos, buffer, len);
+ memcpy ((uint8_t *) rcoH->tables + rcoH->memPos, buffer, len);
if (len % 4) {
- memset ((uint8 *) rcoH->tables + rcoH->memPos + len, 0, 4 - (len % 4));
+ memset ((uint8_t *) rcoH->tables + rcoH->memPos + len, 0, 4 - (len % 4));
}
rcoH->memPos += len4;
if (rcoH->memPos > rcoH->tablesSize)
// always add 4 byte padding (should add an argument, but will always be
// TRUE anyway, so I cbf)
if (len % 4) {
- uint32 zero = 0;
+ uint32_t zero = 0;
filewrite (rcoH->fp, &zero, 4 - (len % 4));
}
}
}
-uint
+uint32_t
rcowrite_ftell (rRCOFile_writehelper * rcoH)
{
// memory stuff
}
void
-rcowrite_fseek (rRCOFile_writehelper * rcoH, uint pos)
+rcowrite_fseek (rRCOFile_writehelper * rcoH, uint32_t pos)
{
// memory stuff
if (rcoH->tables)
// returns the length of the packed data
// TBH, I really can't be stuffed writing a buffered copy/compress/decompressor
// (and anyway, it may not work with future compression routines, so meh)
-uint
-rco_write_resource (FILE * dest, rRCOEntry * entry, uint destCompression,
+uint32_t
+rco_write_resource (FILE * dest, rRCOEntry * entry, uint32_t destCompression,
writerco_options * opts, rRCOFile * rco)
{
- uint len = 0;
- uint8 *bufferMid = (uint8 *) read_resource (entry, &len);
+ uint32_t len = 0;
+ uint8_t *bufferMid = (uint8_t *) read_resource (entry, &len);
if (!bufferMid) {
if (entry->labelOffset)
return 0;
}
- uint8 *bufferOut;
- uint packedSize = 0;
+ uint8_t *bufferOut;
+ uint32_t packedSize = 0;
if (destCompression == RCO_DATA_COMPRESSION_ZLIB) {
- uint compSize = compressBound (entry->srcLenUnpacked);
+ uint32_t compSize = compressBound (entry->srcLenUnpacked);
- bufferOut = (uint8 *) malloc (compSize);
+ bufferOut = (uint8_t *) malloc (compSize);
packedSize =
zlib_compress (bufferMid, entry->srcLenUnpacked, bufferOut, compSize,
opts->zlibLevel, opts->zlibMethod);
error ("RLZ compression not supported.");
exit (1);
#endif
- bufferOut = (uint8 *) malloc (entry->srcLenUnpacked);
+ bufferOut = (uint8_t *) malloc (entry->srcLenUnpacked);
packedSize =
rlz_compress (bufferMid, entry->srcLenUnpacked, bufferOut,
entry->srcLenUnpacked, opts->rlzMode);
free (bufferOut);
/*
- * char buffer[65536], outBuffer[65536]; uint len=entry->srcLen; z_stream
+ * char buffer[65536], outBuffer[65536]; uint32_t len=entry->srcLen; z_stream
* out; if(destStream == RCO_DATA_COMPRESSION_ZLIB) { ZLIB_INIT_DEFLATE(out,
* 9, Z_DEFAULT_STRATEGY); out.next_in = buffer; out.avail_in = 65536;
* out.next_out = outBuffer; out.avail_out = 65536; }
*
- * // copy with buffer while(len) { uint readAmt = (len < 65536 ? len :
+ * // copy with buffer while(len) { uint32_t readAmt = (len < 65536 ? len :
* 65536); if(!fileread(src, &buffer, readAmt)) { fclose(src); return FALSE;
* }
*
// 4byte alignment
if (packedSize % 4) {
- uint32 zero = 0;
+ uint32_t zero = 0;
filewrite (dest, &zero, 4 - (packedSize % 4));
}
return packedSize;
}
-uint
+uint32_t
rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
- uint destCompression, writerco_options * opts, uint lang, Bool isLast)
+ uint32_t destCompression, writerco_options * opts, uint32_t lang, uint8_t isLast)
{
- uint len = 0;
- uint8 *bufferMid = (uint8 *) read_resource (entry, &len);
+ uint32_t len = 0;
+ uint8_t *bufferMid = (uint8_t *) read_resource (entry, &len);
if (!bufferMid)
return 0;
TextComprInfo tci;
char *textBuffer = NULL;
- uint textBufferPos = 0;
+ uint32_t textBufferPos = 0;
if (destCompression) {
tci.lang = lang;
// textBuffer = (char*)malloc(1);
}
- uint i;
+ uint32_t i;
for (i = 0; i < extra->numIndexes; i++) {
- uint len = extra->indexes[i].length;
+ uint32_t len = extra->indexes[i].length;
if (!len)
continue;
free (bufferMid);
if (destCompression) {
- Bool success = TRUE;
- uint8 *bufferOut = NULL;
+ uint8_t success = TRUE;
+ uint8_t *bufferOut = NULL;
if (destCompression == RCO_DATA_COMPRESSION_ZLIB) {
- uint compSize = compressBound (tci.unpackedLen);
+ uint32_t compSize = compressBound (tci.unpackedLen);
- bufferOut = (uint8 *) malloc (compSize);
+ bufferOut = (uint8_t *) malloc (compSize);
tci.packedLen =
zlib_compress (textBuffer, tci.unpackedLen, bufferOut, compSize,
opts->zlibLevel, opts->zlibMethod);
error ("RLZ compression not supported.");
exit (1);
#endif
- bufferOut = (uint8 *) malloc (tci.unpackedLen);
+ bufferOut = (uint8_t *) malloc (tci.unpackedLen);
tci.packedLen =
rlz_compress (textBuffer, tci.unpackedLen, bufferOut, tci.unpackedLen,
opts->rlzMode);
free (bufferOut);
if (tci.packedLen % 4) {
- uint32 zero = 0;
+ uint32_t zero = 0;
filewrite (rcoH->fp, &zero, 4 - (tci.packedLen % 4));
}
void
rco_write_fix_refs (rRCOEntry * parent, rRCOFile_writehelper * rcoH,
- rRCOFile * rco, const int *lenArray, const int lenNum, Bool isObj)
+ rRCOFile * rco, const int *lenArray, const int lenNum, uint8_t isObj)
{
rRCOEntry *rcoNode;
for (rcoNode = parent->firstChild; rcoNode; rcoNode = rcoNode->next) {
rcowrite_fseek (rcoH, rcoNode->offset + sizeof (RCOEntry));
- uint j, j2;
- uint8 *extraPtr = (uint8 *) rcoNode->extra;
+ uint32_t j, j2;
+ uint8_t *extraPtr = (uint8_t *) rcoNode->extra;
if (rcoNode->type <= lenNum && lenArray[rcoNode->type] > 0) {
const int *typeArray =
(isObj ? RCO_OBJ_EXTRA_TYPES[rcoNode->
type] : RCO_ANIM_EXTRA_TYPES[rcoNode->type]);
for (j = 0, j2 = 0; (int) j < lenArray[rcoNode->type]; j++, j2++) {
- Bool cond;
+ uint8_t cond;
if (isObj)
cond = (RCO_OBJ_IS_REF (rcoNode->type, j2));
// if(!isObj) j2--;
} else {
if (rco->eSwap && typeArray[j2] != RCO_OBJ_EXTRA_TYPE_UNK) {
- uint32 val = *(uint32 *) extraPtr;
+ uint32_t val = *(uint32_t *) extraPtr;
val = ENDIAN_SWAP (val);
rco_fwrite (rcoH, &val, sizeof (val));
} else
- rco_fwrite (rcoH, extraPtr, sizeof (uint32));
- extraPtr += sizeof (uint32);
+ rco_fwrite (rcoH, extraPtr, sizeof (uint32_t));
+ extraPtr += sizeof (uint32_t);
}
}
} else {
}
// returns size of hash table
-uint
+uint32_t
write_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
rRCOFile * rco)
{
- uint num = entry->numSubentries;
+ uint32_t num = entry->numSubentries;
if (entry->id == RCO_TABLE_OBJ)
num = count_all_subentries (entry);
if (!num)
return 0;
- uint32 *hashTable = (uint32 *) malloc (num * sizeof (uint32));
+ uint32_t *hashTable = (uint32_t *) malloc (num * sizeof (uint32_t));
- memset (hashTable, 0, num * sizeof (uint32));
+ memset (hashTable, 0, num * sizeof (uint32_t));
rRCOEntry *rcoNode;
for (rcoNode = entry->firstChild; rcoNode; rcoNode = rcoNode->next)
do_hashing (rcoNode, rco, (entry->id == RCO_TABLE_OBJ), hashTable, num);
// write it
- rco_fwrite (rcoH, hashTable, num * sizeof (uint32));
+ rco_fwrite (rcoH, hashTable, num * sizeof (uint32_t));
free (hashTable);
return num;
}
-uint
+uint32_t
write_text_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry,
rRCOFile * rco)
{
- uint num = ((rRCOTextEntry *) entry->extra)->numIndexes;
+ uint32_t num = ((rRCOTextEntry *) entry->extra)->numIndexes;
if (!num)
return 0;
- uint32 *hashTable = (uint32 *) malloc (num * sizeof (uint32));
+ uint32_t *hashTable = (uint32_t *) malloc (num * sizeof (uint32_t));
- memset (hashTable, 0, num * sizeof (uint32));
- uint i;
+ memset (hashTable, 0, num * sizeof (uint32_t));
+ uint32_t i;
for (i = 0; i < num; i++) {
RCOTextIndex *ti = &(((rRCOTextEntry *) entry->extra)->indexes[i]);
if (ti->labelOffset != RCO_NULL_PTR) {
- uint32 *hashPtr =
+ uint32_t *hashPtr =
&hashTable[calc_hash (rco->labels + ti->labelOffset, hashTable, num)];
*hashPtr =
entry->offset + sizeof (RCOEntry) + sizeof (RCOTextEntry) +
}
// write it
- rco_fwrite (rcoH, hashTable, num * sizeof (uint32));
+ rco_fwrite (rcoH, hashTable, num * sizeof (uint32_t));
free (hashTable);
return num;
}
void
-do_hashing (rRCOEntry * entry, rRCOFile * rco, Bool recurse, uint32 * hashTable,
- uint hashTableSize)
+do_hashing (rRCOEntry * entry, rRCOFile * rco, uint8_t recurse, uint32_t * hashTable,
+ uint32_t hashTableSize)
{
if (entry->labelOffset != RCO_NULL_PTR) {
- uint32 *hashPtr =
+ uint32_t *hashPtr =
&hashTable[calc_hash (rco->labels + entry->labelOffset, hashTable,
hashTableSize)];
}
}
-uint
-calc_hash (char *in, uint32 * hashTable, uint hashTableSize)
+uint32_t
+calc_hash (char *in, uint32_t * hashTable, uint32_t hashTableSize)
{
- uint32 hash = 0;
+ uint32_t hash = 0;
// calculate hash code (just a summation of the chars)
while (*in) {
#define VAG_SIGNATURE 0x70474156
#define VAG_VERSION 0x4000000 // 0x2000000
PACK_STRUCT (VagHeader, {
- uint32 signature; // "VAGp"
- uint32 version; // 0x20
- uint32 reserved; // 0
- uint32 dataSize; // size of file - 0x30
- uint32 frequency;
- uint8 reserved2[12]; // 0
+ uint32_t signature; // "VAGp"
+ uint32_t version; // 0x20
+ uint32_t reserved; // 0
+ uint32_t dataSize; // size of file - 0x30
+ uint32_t frequency;
+ uint8_t reserved2[12]; // 0
char name[16];
char unknown[16];
});
#define WAV_PCM_FORMAT 1
#define WAV_S2_SIG 0x61746164
PACK_STRUCT (WavHeader, {
- uint32 signature; // "RIFF"
- uint32 size; // filesize - 8
- uint32 format; // "WAVE"
- uint32 s1sig; // "fmt "
- uint32 s1size; // 16 for PCM
- uint16 audioFmt; // PCM = 1
- uint16 channels;
- uint32 frequency;
- uint32 byterate; // = frequency * channels * bitDepth/8
- uint16 sampleSize; // = channels * bitDepth / 8
- uint16 bitDepth; // we'll always use 16
- uint32 s2sig; // "data"
- uint32 s2size; // = numSamples * channels * bitDepth/8 OR
+ uint32_t signature; // "RIFF"
+ uint32_t size; // filesize - 8
+ uint32_t format; // "WAVE"
+ uint32_t s1sig; // "fmt "
+ uint32_t s1size; // 16 for PCM
+ uint16_t audioFmt; // PCM = 1
+ uint16_t channels;
+ uint32_t frequency;
+ uint32_t byterate; // = frequency * channels * bitDepth/8
+ uint16_t sampleSize; // = channels * bitDepth / 8
+ uint16_t bitDepth; // we'll always use 16
+ uint32_t s2sig; // "data"
+ uint32_t s2size; // = numSamples * channels * bitDepth/8 OR
// size-36
});
// TODO: sanity checks with lengths
-Bool
+uint8_t
vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData)
{
filewrite (fp, &wh, sizeof (wh));
- int wavSamplesSize = numChannels * 28 * sizeof (int16);
- int16 *wavSamples = (int16 *) malloc (wavSamplesSize);
+ int wavSamplesSize = numChannels * 28 * sizeof (int16_t);
+ int16_t *wavSamples = (int16_t *) malloc (wavSamplesSize);
double *factors = (double *) calloc (numChannels * 2, sizeof (double));
while (TRUE) {
- Bool notEnded = FALSE;
+ uint8_t notEnded = FALSE;
memset (wavSamples, 0, numChannels * 28);
for (i = 0; i < numChannels; i++) {
samples[j * 2 + 1] = (vc->s[j] & 0xF0) >> 4;
}
for (j = 0; j < 28; j++) {
- int s = samples[j] << 12; // shift 4 bits to top range of int16
+ int s = samples[j] << 12; // shift 4 bits to top range of int16_t
if (s & 0x8000)
s |= 0xFFFF0000;
factors[i * 2 + 1] * f[predict][1];
factors[i * 2 + 1] = factors[i * 2];
factors[i * 2] = sample;
- wavSamples[j * numChannels + i] = (int16) ROUND (sample);
+ wavSamples[j * numChannels + i] = (int16_t) ROUND (sample);
}
notEnded = TRUE;
}
free (wavSamples);
free (factors);
- if (wh.size != (uint32) (ftell (fp) - 8)) { // fixup WAV sizes if wrong
+ if (wh.size != (uint32_t) (ftell (fp) - 8)) { // fixup WAV sizes if wrong
if (strcmp (fWav, "-")) { // can only fix if not writing to stdout
wh.size = ftell (fp) - 8;
wh.s2size = wh.size - 36;
}
int
-wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName)
+wav2vag (const char *fWav, uint32_t * len, void **vagData, const char *vagName)
{
FILE *fp = openread (fWav);
("File '%s' appears to have a non-standard header length for PCM. Attempting to auto-skip...",
fWav);
fseek (fp,
- sizeof (wh) + (wh.s1size - WAV_S1_SIZE_PCM) - sizeof (uint32) * 2,
+ sizeof (wh) + (wh.s1size - WAV_S1_SIZE_PCM) - sizeof (uint32_t) * 2,
SEEK_SET);
- fileread (fp, &wh.s2sig, sizeof (uint32));
+ fileread (fp, &wh.s2sig, sizeof (uint32_t));
}
if (wh.s1sig != WAV_S1_SIG || wh.s2sig != WAV_S2_SIG)
WAV2VAG_ERROR_EXIT
int i, j, k;
// size compression is 28 16-bit samples -> 16 bytes
- uint numSamples = wh.s2size / wh.sampleSize;
+ uint32_t numSamples = wh.s2size / wh.sampleSize;
*len =
(numSamples / 28 + (numSamples % 28 ? 2 : 1)) * sizeof (VagChunk) +
strncpy (vh->name, vagName, 16);
}
- uint pos;
+ uint32_t pos;
int wavBufSize = 28 * (wh.bitDepth / 8) * wh.channels;
- int16 *wavBuf = (int16 *) malloc (wavBufSize);
+ int16_t *wavBuf = (int16_t *) malloc (wavBufSize);
double *factors = (double *) calloc (wh.channels * 2, sizeof (double));
double *factors2 = (double *) calloc (wh.channels * 2, sizeof (double));
WAV2VAG_ERROR_EXIT ("Premature end in WAV file '%s'; conversion failed.")}
if (pos + 28 > numSamples)
memset (wavBuf + ((numSamples -
- pos) * (wh.bitDepth / 8) * wh.channels / sizeof (int16)), 0,
+ pos) * (wh.bitDepth / 8) * wh.channels / sizeof (int16_t)), 0,
(28 - numSamples + pos) * (wh.bitDepth / 8) * wh.channels);
- uint ch;
+ uint32_t ch;
for (ch = 0; ch < wh.channels; ch++) {
VagChunk *vc =
factors[ch * 2 + 1] = s2[predict];
// find_shift
- uint shiftMask;
+ uint32_t shiftMask;
for (shift = 0, shiftMask = 0x4000; shift < 12; shift++, shiftMask >>= 1) {
if (shiftMask & ((int) min + (shiftMask >> 3)))
// I don't understand it, but it seems that the second transformation is
// required to prevent a clipping sound effect although it should produce
// worse reconverts...
- int8 outBuf[28];
+ int8_t outBuf[28];
for (k = 0; k < 28; k++) {
double s_double_trans =
if (sample < -32768)
sample = -32768;
- outBuf[k] = (int8) (sample >> 12);
+ outBuf[k] = (int8_t) (sample >> 12);
factors2[ch * 2 + 1] = factors2[ch * 2];
factors2[ch * 2] = (double) (sample >> shift) - s_double_trans;
}
/* { int samples[28]; // expand 4bit -> 8bit for(j=0; j<14; j++) {
* samples[j*2] = vc->s[j] & 0xF; samples[j*2+1] = (vc->s[j] & 0xF0) >>
* 4; } for(j=0; j<28; j++) { int s = samples[j] << 12; // shift 4 bits
- * to top range of int16 if(s & 0x8000) s |= 0xFFFF0000; double sample =
+ * to top range of int16_t if(s & 0x8000) s |= 0xFFFF0000; double sample =
* (double)(s >> shift) + factors2[ch*2] * f[predict][0] +
* factors2[ch*2+1] * f[predict][1]; factors2[ch*2+1] = factors2[ch*2];
* factors2[ch*2] = sample; if(wavBuf[j*wh.channels + ch] !=
- * (int16)ROUND(sample)) { printf("a"); } } } */
+ * (int16_t)ROUND(sample)) { printf("a"); } } } */
}
}
}
/*
- * int wav2vag(const char* fWav, uint* len, void** vagData, const char*
+ * int wav2vag(const char* fWav, uint32_t* len, void** vagData, const char*
* vagName) { FILE* fp = fopen(fWav, "rb"); if(!fp) return 0;
*
* WavHeader wh; fileread(fp, &wh, sizeof(wh));
* header for '%s'.")
*
*
- * int i, j, k; // size compression is 28 16-bit samples -> 16 bytes uint
+ * int i, j, k; // size compression is 28 16-bit samples -> 16 bytes uint32_t
* numSamples = wh.s2size / wh.sampleSize; *len = (numSamples/28 + (numSamples
* % 28 ? 2:1)) * sizeof(VagChunk) + sizeof(VagHeader); *vagData = calloc(1,
* *len * wh.channels);
* - 0x30); vh->frequency = ENDIAN_SWAP(wh.frequency); strncpy(vh->name,
* vagName, 16); }
*
- * uint pos; int wavBufSize = 28 * (wh.bitDepth/8) * wh.channels; int16* wavBuf
- * = (int16*)malloc(wavBufSize); double* factors =
+ * uint32_t pos; int wavBufSize = 28 * (wh.bitDepth/8) * wh.channels; int16_t* wavBuf
+ * = (int16_t*)malloc(wavBufSize); double* factors =
* (double*)calloc(wh.channels*2, sizeof(double)); double* factors2 =
* (double*)calloc(wh.channels*2, sizeof(double)); for(pos=0; pos<numSamples;
* pos += 28) { if(!fileread(fp, wavBuf, wavBufSize)) { free(wavBuf);
* free(factors); free(factors2); WAV2VAG_ERROR_EXIT("Premature end in WAV file
* '%s'; conversion failed.") }
*
- * uint ch; for(ch=0; ch<wh.channels; ch++) { VagChunk* vc =
+ * uint32_t ch; for(ch=0; ch<wh.channels; ch++) { VagChunk* vc =
* (VagChunk*)((char*)(*vagData) + *len * ch + sizeof(VagHeader) +
* sizeof(VagChunk)*(pos/28));
*
* predict = j; // ???? store s1 & s2 into temp place? } // ???? if(min <= 7) {
* predict = 0; break; } } // ???? factors[ch*2] = s1; factors[ch*2+1] = s2;
*
- * // find_shift uint shiftMask; for(shift=0, shiftMask=0x4000; shift<12;
+ * // find_shift uint32_t shiftMask; for(shift=0, shiftMask=0x4000; shift<12;
* shift++, shiftMask>>=1) { if(shiftMask & ((int)min + (shiftMask >> 3)))
* break; } // so shift==12 if none found...
*
* vc->predict_shift = ((predict << 4) & 0xF0) | (shift & 0xF); vc->flags =
* (numSamples - pos >= 28 ? 0:1);
*
- * // pack uint8 outBuf[28]; for(k=0; k<28; k++) { double sample =
+ * // pack uint8_t outBuf[28]; for(k=0; k<28; k++) { double sample =
* predictBuf[predict][k] - factors2[ch*2] * f[predict][0] - factors2[ch*2+1] *
* f[predict][1]; int sample2 = ((int)(sample * (1 << shift)) + 0x800) &
* 0xfffff000; if(sample2 > 32767) sample2 = 32767; if(sample2 < -32768) sample2
- * = -32768; outBuf[k] = (uint8)(sample2 >> 8); sample2 >>= shift;
+ * = -32768; outBuf[k] = (uint8_t)(sample2 >> 8); sample2 >>= shift;
* factors2[ch*2+1] = factors2[ch*2]; factors2[ch*2] = (double)sample2 - sample;
* } for(k=0; k<14; k++) vc->s[k] = (outBuf[k*2+1] & 0xF0) | ((outBuf[k*2] >> 4)
* & 0xF); } }
#include "general.h"
-Bool vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData);
-int wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName);
+uint8_t vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData);
+int wav2vag (const char *fWav, uint32_t * len, void **vagData, const char *vagName);
{
VSMXHeader header;
- uint filePos;
+ uint32_t filePos;
VsmxMem *out;
fileread (fp, &header, sizeof (header));
pVar = (typ **)malloc(te * sizeof(typ *)); \
pVar[0] = var; \
\
- uint pti = 1, ci; \
+ uint32_t pti = 1, ci; \
for(ci = 1; ci < tl / sizeof(typ); ci++) { \
if(var[ci-1] == 0) { \
if(pti == te) { \
{
VSMXHeader *header = (VSMXHeader *) in;
- uint filePos;
+ uint32_t filePos;
VsmxMem *out;
if (header->sig != VSMX_SIGNATURE || header->ver != VSMX_VERSION) {
// TODO: check lengths are in sane ranges
out->code = (VSMXGroup *) malloc (header->codeLength);
- memcpy (out->code, (uint8 *) in + header->codeOffset, header->codeLength);
+ memcpy (out->code, (uint8_t *) in + header->codeOffset, header->codeLength);
out->codeGroups = header->codeLength / sizeof (VSMXGroup);
filePos = header->codeOffset + header->codeLength;
} \
\
var = (typ *)malloc(tl +sizeof(typ)); \
- memcpy(var, (uint8*)in + filePos, tl); \
+ memcpy(var, (uint8_t*)in + filePos, tl); \
var[tl / sizeof(typ)] = 0; \
\
pVar = (typ **)malloc(te * sizeof(typ *)); \
pVar[0] = var; \
\
- uint pti = 1, ci; \
+ uint32_t pti = 1, ci; \
for(ci = 1; ci < tl / sizeof(typ); ci++) { \
if(var[ci-1] == 0) { \
if(pti == te) { \
pos = sizeof (VSMXHeader);
if (in->code) {
- memcpy ((uint8 *) ret + pos, in->code, header->codeLength);
+ memcpy ((uint8_t *) ret + pos, in->code, header->codeLength);
pos += header->codeLength;
}
if (in->text) {
- memcpy ((uint8 *) ret + pos, in->text, header->textLength);
+ memcpy ((uint8_t *) ret + pos, in->text, header->textLength);
pos += header->textLength;
}
if (in->prop) {
- memcpy ((uint8 *) ret + pos, in->prop, header->propLength);
+ memcpy ((uint8_t *) ret + pos, in->prop, header->propLength);
pos += header->propLength;
}
if (in->names) {
- memcpy ((uint8 *) ret + pos, in->names, header->namesLength);
+ memcpy ((uint8_t *) ret + pos, in->names, header->namesLength);
pos += header->namesLength;
}
return ret;
int
VsmxDecode (VsmxMem * in, FILE * out)
{
- uint i;
+ uint32_t i;
fputws (L"; Decoded VSMX file written by " APPNAME_VER "\n\n", out);
// for some reason, the %s modifier in fwprintf doesn't work
// properly... :/ so we need to convert to a wide char string
wchar *tmp;
- uint tmpLen = strlen (in->pNames[in->code[i].val.u32]);
+ uint32_t tmpLen = strlen (in->pNames[in->code[i].val.u32]);
CHECK_INDEX (in->numNames, "name");
tmp = (wchar *) malloc ((tmpLen + 1) * sizeof (wchar));
}
for (p = 0; p < *numText; p++) {
- Bool cond;
+ uint8_t cond;
if (charWidth == 1) {
cond = strcmp (*(char **) text + (*offs)[p], newTextByte);
int arrayFlag;
VsmxDecompileStack *prev;
- uint depth;
+ uint32_t depth;
};
static inline void
typedef struct __VsmxDecompMarkStack VsmxDecompMarkStack;
struct __VsmxDecompMarkStack {
- uint loc;
- uint src;
+ uint32_t loc;
+ uint32_t src;
VsmxDecompMarkStack *prev;
- uint depth;
+ uint32_t depth;
};
static inline void
if (newItem->loc > (*stack)->loc) {
warning ("Bad nesting hierachy detected!");
// well, what to do? Just switch them around I guess...
- uint tmp = newItem->loc;
+ uint32_t tmp = newItem->loc;
newItem->loc = (*stack)->loc;
(*stack)->loc = tmp;
}
static inline void
-writeTabs (FILE * out, uint num)
+writeTabs (FILE * out, uint32_t num)
{
while (num--)
fputwc ('\t', out);
int
VsmxDecompile (VsmxMem * in, FILE * out)
{
- uint i, indent = 0, stmtStart = 0;
+ uint32_t i, indent = 0, stmtStart = 0;
int indentAdd = 0;
VsmxDecompileStack *stack = NULL;
VsmxDecompileStack item;
VsmxDecompMarkStack *mStack = NULL;
VsmxDecompMarkStack mItem;
- uint endStmtConcat = 1;
+ uint32_t endStmtConcat = 1;
- uint forStmtEnd = 0;
+ uint32_t forStmtEnd = 0;
fputws (L"// Decompiled VSMX -> Javascript output by " APPNAME_VER
"\n//Note, this is highly experimental and the output probably sucks.\n\n",
// stuff we'll use later
wchar op[50] = { 0 };
- Bool notSectStart = FALSE;
+ uint8_t notSectStart = FALSE;
/* #ifdef MINGW #define SWPRINTF_ITEM(s, ...) swprintf(item.str, L##s,
* __VA_ARGS__) #else #define SWPRINTF_ITEM(s, ...) swprintf(item.str,
else {
wcscpy (item.str, L"true");
if (in->code[i].val.u32 != 1)
- warning ("Boolean value at group #%d is not 0 or 1.", i);
+ warning ("uint8_tean value at group #%d is not 0 or 1.", i);
}
VsmxDecompileStackPush (&stack, &item);
break;
case VID_MAKE_FLOAT_ARRAY:
{
VsmxDecompileStack *prev;
- uint j;
+ uint32_t j;
for (j = 0; j < in->code[i].val.u32; j++) {
prev = VsmxDecompileStackPop (&stack);
item.arrayFlag = 2;
VsmxDecompileStackPush (&stack, &item);
} else {
- uint aLen = wcslen (array->str);
+ uint32_t aLen = wcslen (array->str);
if (aLen < 3) {
error ("Internal array handling error at %d!", i);
{
// TODO: need to check marker stack for look aheads
// !!! note look ahead used!
- Bool funcEndStmtStyle = (i + 3 < in->codeGroups &&
+ uint8_t funcEndStmtStyle = (i + 3 < in->codeGroups &&
in->code[i + 2].id == VID_END_STMT &&
in->code[i + 3].id == VID_SECT_START &&
in->code[i].val.u32 == i + 4);
wchar args[4096] = L""; // large enough for anything
- uint numArgs = (in->code[i].id >> 8) & 0xFF, argI;
+ uint32_t numArgs = (in->code[i].id >> 8) & 0xFF, argI;
if (in->code[i].id >> 16 & 0xFF) {
warning
VsmxDecompileStack *prev;
if (in->code[i].val.u32 > 0) {
- uint arg;
+ uint32_t arg;
strwcpy (item.str, " )", MAX_TEXT_LEN);
for (arg = 0; arg < in->code[i].val.u32; arg++) {
#define VSMX_SIGNATURE 0x584D5356 // "VSMX"
#define VSMX_VERSION 0x00010000
PACK_STRUCT (VSMXHeader, {
- uint32 sig; uint32 ver; uint32 codeOffset; uint32 codeLength;
- uint32 textOffset; uint32 textLength; uint32 textEntries;
- uint32 propOffset;
- uint32 propLength; uint32 propEntries; uint32 namesOffset;
- uint32 namesLength;
- uint32 namesEntries;
+ uint32_t sig; uint32_t ver; uint32_t codeOffset; uint32_t codeLength;
+ uint32_t textOffset; uint32_t textLength; uint32_t textEntries;
+ uint32_t propOffset;
+ uint32_t propLength; uint32_t propEntries; uint32_t namesOffset;
+ uint32_t namesLength;
+ uint32_t namesEntries;
});
PACK_STRUCT (VSMXGroup, {
- uint32 id;
+ uint32_t id;
union {
- uint32 u32;
+ uint32_t u32;
float f;
} val;
});
wchar **pText, **pProp;
char **pNames;
- uint codeGroups, numText, numProp, numNames, lenText, lenProp, lenNames;
+ uint32_t codeGroups, numText, numProp, numNames, lenText, lenProp, lenNames;
} VsmxMem;
VsmxMem *readVSMX (FILE * fp);
#include "general.h"
#include "rcomain.h"
-Bool write_xml (rRCOFile * rco, FILE * fp, char *textDir, Bool textXmlOut,
- int sndDumped, Bool vsmxConv);
+uint8_t write_xml (rRCOFile * rco, FILE * fp, char *textDir, uint8_t textXmlOut,
+ int sndDumped, uint8_t vsmxConv);
rRCOFile *read_xml (char *fn);
#define RCOXML_TABLE_2ND_DIM 20
extern RcoTagMap RCOXML_TABLE_TAGS;
-extern uint RCOXML_TABLE_TAGS_NUM;
+extern uint32_t RCOXML_TABLE_TAGS_NUM;
extern RcoTableMap RCOXML_TABLE_NAMES;
-void rcoxml_int_to_text (uint in, const RcoTableMap map, char *out);
-Bool rcoxml_text_to_int (char *s, const RcoTableMap map, uint * out);
+void rcoxml_int_to_text (uint32_t in, const RcoTableMap map, char *out);
+uint8_t rcoxml_text_to_int (char *s, const RcoTableMap map, uint32_t * out);
#endif
// xmlChar *ptrText, *ptrImg, *ptrSound, *ptrModel, *ptrObj, *ptrAnim;
xmlChar *textData; // labels data, that is
// xmlrco_read_fix_refs* refs;
- // uint refsCnt;
+ // uint32_t refsCnt;
} rcoxml_read_fixes;
void parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco,
rcoxml_read_fixes * fixes);
-// Bool rcoxml_text_to_int(char* s, const RcoTableMap map, uint* out);
-uint rcoxml_add_label (char **labels, uint * labelsLen, char *label,
- Bool eventQuirk);
-uint rcoxml_add_label_reordering (char *newLabels, uint * labelPos,
+// uint8_t rcoxml_text_to_int(char* s, const RcoTableMap map, uint32_t* out);
+uint32_t rcoxml_add_label (char **labels, uint32_t * labelsLen, char *label,
+ uint8_t eventQuirk);
+uint32_t rcoxml_add_label_reordering (char *newLabels, uint32_t * labelPos,
char *label);
-void rcoxml_reorder_labels (char *newLabels, uint * labelPos, rRCOFile * rco,
+void rcoxml_reorder_labels (char *newLabels, uint32_t * labelPos, rRCOFile * rco,
rRCOEntry * entry);
int label_reorder_qsort (const rRCOEntry ** a, const rRCOEntry ** b);
void parse_obj_extra (xmlNodePtr node, rRCOEntry * entry);
void parse_anim_extra (xmlNodePtr node, rRCOEntry * entry);
-xmlChar *rcoxml_get_unknown_attrib (xmlNodePtr node, uint num);
-uint32 rcoxml_parse_value (char *s);
-Bool rcoxml_parse_ref (char *val, rRCORef * out);
+xmlChar *rcoxml_get_unknown_attrib (xmlNodePtr node, uint32_t num);
+uint32_t rcoxml_parse_value (char *s);
+uint8_t rcoxml_parse_ref (char *val, rRCORef * out);
void rcoxml_fix_refs (rRCOEntry * entry, rRCOFile * rco);
-Bool rcoxml_fix_ref (rRCORef * ref, rRCOFile * rco);
-void rcoxml_fix_ptrs (rRCOEntry *** sect, uint * sectCnt, rRCOFile * rco,
+uint8_t rcoxml_fix_ref (rRCORef * ref, rRCOFile * rco);
+void rcoxml_fix_ptrs (rRCOEntry *** sect, uint32_t * sectCnt, rRCOFile * rco,
const char *text);
-uint split_comma_list (char *s);
+uint32_t split_comma_list (char *s);
char *strtrimr (char *in);
char *expand_fname_to_fmt (char *in, char type);
-Bool parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry);
+uint8_t parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry);
rRCOFile *
read_xml (char *fn)
{
xmlDocPtr doc;
xmlNodePtr node;
- Bool bValidDoc = FALSE;
+ uint8_t bValidDoc = FALSE;
rcoxml_read_fixes fixes; // post fixes need to be done
while (!feof (stdin)) {
buf = (char *) realloc (buf, bufsize + 65536);
- uint readAmt = fread (buf + bufsize, 1, 65536, stdin);
+ uint32_t readAmt = fread (buf + bufsize, 1, 65536, stdin);
if (!readAmt)
break;
xmlChar *verId = xmlGetProp (node, _X ("minFirmwareVer"));
if (verId) {
- uint verIdInt = 0;
+ uint32_t verIdInt = 0;
float verIdFlt = 0;
if (sscanf ((const char *) verId, "unknownId%i", &verIdInt))
char *newLabels = (char *) malloc (rco->labelsLen);
memset (newLabels, 0, rco->labelsLen);
- uint labelPos = 0;
+ uint32_t labelPos = 0;
// don't forget to add the main table label :P
if (rco->tblMain.labelOffset != RCO_NULL_PTR)
rco->labels + rco->tblMain.labelOffset);
// we re-order in order of IDs
- uint i;
+ uint32_t i;
rRCOEntry **sList =
make_sorted_list_of_subentries (&rco->tblMain, label_reorder_qsort);
for (i = 0; i < rco->tblMain.numSubentries; i++)
parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco,
rcoxml_read_fixes * fixes)
{
- uint i, j;
- Bool knownEntryType = TRUE;
+ uint32_t i, j;
+ uint8_t knownEntryType = TRUE;
// crap all over the memory in "entry" so we don't screw stuff over later on
entry->id = entry->type = 0;
se->channelData = NULL;
RCOXML_READ_ATTRIB_AS_INT (node, "format", RCOXML_TABLE_SOUND_FMT,
- (uint *) & (se->format),
+ (uint32_t *) & (se->format),
"No format attribute defined, defaulting to VAG.");
xmlChar *chStr = xmlGetProp (node, _X ("channels"));
- uint16 ch = 0;
+ uint16_t ch = 0;
if (chStr)
- ch = (uint16) strtol ((const char *) chStr, NULL, 10);
+ ch = (uint16_t) strtol ((const char *) chStr, NULL, 10);
if (ch > 0)
se->channels = ch;
else if (!strcasecmp (entry->srcFile + strlen (entry->srcFile) - 4,
if (se->channels) {
se->channelData =
- (uint32 *) malloc (se->channels * sizeof (uint32) * 2);
- memset (se->channelData, 0, se->channels * sizeof (uint32) * 2);
+ (uint32_t *) malloc (se->channels * sizeof (uint32_t) * 2);
+ memset (se->channelData, 0, se->channels * sizeof (uint32_t) * 2);
xmlChar *srcPartsX = xmlGetProp (node, _X ("srcParts"));
if (srcPartsX) {
char *srcParts = (char *) srcPartsX;
- uint numParts = split_comma_list (srcParts);
+ uint32_t numParts = split_comma_list (srcParts);
if (numParts == se->channels) {
for (i = 0; i < se->channels; i++) {
// TODO: loop thru each file, record size and add to buffer
if (strlen (srcFileFmt) < MAX_FILENAME_LEN) {
char srcFile[MAX_FILENAME_LEN];
- uint curPos = 0;
+ uint32_t curPos = 0;
void *srcBufferTmp = malloc (1);
for (i = 0; i < se->channels; i++) {
srcBufferTmp =
realloc (srcBufferTmp,
curPos + ALIGN_TO_4 (se->channelData[i * 2]));
- uint8 *bufferPos = (uint8 *) (srcBufferTmp) + curPos;
+ uint8_t *bufferPos = (uint8_t *) (srcBufferTmp) + curPos;
fileread (fp, bufferPos, se->channelData[i * 2]);
fclose (fp);
case RCO_TABLE_TEXT:
if (entry->type == 1) {
- Bool xmlInput = FALSE;
+ uint8_t xmlInput = FALSE;
entry->extraLen = sizeof (rRCOTextEntry);
entry->extra = malloc (entry->extraLen);
te->numIndexes = 0;
RCOXML_READ_ATTRIB_AS_INT (node, "language", RCOXML_TABLE_TEXT_LANG,
- (uint *) & te->lang,
+ (uint32_t *) & te->lang,
"No language attribute defined - RCO may no longer be valid.");
RCOXML_READ_ATTRIB_AS_INT (node, "format", RCOXML_TABLE_TEXT_FMT,
- (uint *) & te->format,
+ (uint32_t *) & te->format,
"No destination format defined - assuming UTF16.");
if (te->format != RCO_TEXT_FMT_UTF16 && !rco->ps3) {
if (srcPartsX) {
char *srcParts = (char *) srcPartsX;
- uint numParts = split_comma_list (srcParts);
+ uint32_t numParts = split_comma_list (srcParts);
if (numParts == te->numIndexes) {
for (i = 0; i < te->numIndexes; i++) {
// loop thru each file, record size and add to buffer
if (strlen (srcFileFmt) < MAX_FILENAME_LEN) {
char srcFile[MAX_FILENAME_LEN];
- uint curPos = 0;
+ uint32_t curPos = 0;
void *srcBufferTmp = malloc (1);
for (i = 0; i < te->numIndexes; i++) {
// aren't
// used
char srcFmt[10] = "", destFmt[8];
- uint32 bom32le = UTF32_BOM;
- uint32 bom32be = ENDIAN_SWAP (UTF32_BOM);
- uint16 bom16le = UTF16_BOM;
- uint16 bom16be = ENDIAN_SWAP (UTF16_BOM);
- uint32 bom8 = UTF8_BOM;
- uint bomLen =
+ uint32_t bom32le = UTF32_BOM;
+ uint32_t bom32be = ENDIAN_SWAP (UTF32_BOM);
+ uint16_t bom16le = UTF16_BOM;
+ uint16_t bom16be = ENDIAN_SWAP (UTF16_BOM);
+ uint32_t bom8 = UTF8_BOM;
+ uint32_t bomLen =
(te->format ==
RCO_TEXT_FMT_UTF32 ? 4 : (te->format ==
RCO_TEXT_FMT_UTF8 ? 3 : 2));
realloc (srcBufferTmp,
curPos + ALIGN_TO_4 (te->indexes[i].length +
bomLen));
- uint8 *bufferPos = (uint8 *) srcBufferTmp + curPos;
+ uint8_t *bufferPos = (uint8_t *) srcBufferTmp + curPos;
if (strcmp (srcFmt, destFmt)) {
- uint fPos = ftell (fp);
- uint fSize;
+ uint32_t fPos = ftell (fp);
+ uint32_t fSize;
fseek (fp, 0, SEEK_END);
fSize = ftell (fp) - fPos;
fseek (fp, fPos, SEEK_SET);
- uint8 *fBuf = (uint8 *) malloc (fSize);
+ uint8_t *fBuf = (uint8_t *) malloc (fSize);
fileread (fp, fBuf, fSize);
iconv_t ic = iconv_open (destFmt, srcFmt);
ALIGN_TO_4 (te->indexes[i].length + bomLen) -
(te->indexes[i].length));
- /* uint16 unisig; if(te->indexes[i].length >= 2)
+ /* uint16_t unisig; if(te->indexes[i].length >= 2)
* fileread(fp, &unisig, sizeof(unisig));
* if(te->indexes[i].length == 1 || unisig !=
* UNICODE_SIGNATURE) { te->indexes[i].length += 2; //
* } if(te->indexes[i].length <= 2) { // this is
* probably blank te->indexes[i].length = 0; } else {
* srcBufferTmp = realloc(srcBufferTmp, curPos +
- * ALIGN_TO_4(te->indexes[i].length)); uint8* bufferPos
- * = (uint8*)srcBufferTmp + curPos; fileread(fp,
+ * ALIGN_TO_4(te->indexes[i].length)); uint8_t* bufferPos
+ * = (uint8_t*)srcBufferTmp + curPos; fileread(fp,
* bufferPos, te->indexes[i].length-2); // add
* terminating null & any necessary padding
* memset(bufferPos + (te->indexes[i].length-2), 0,
}
-Bool
-rcoxml_text_to_int (char *s, const RcoTableMap map, uint * out)
+uint8_t
+rcoxml_text_to_int (char *s, const RcoTableMap map, uint32_t * out)
{
if (!s[0])
return FALSE;
while (map[i][0]) {
if (!strcasecmp (map[i], s)) {
- *out = (uint) i;
+ *out = (uint32_t) i;
return TRUE;
}
i++;
}
// currently very basic - resize when adding a label
-// uint rcoxml_add_label(rRCOFile* rco, char* label) {
-uint
-rcoxml_add_label (char **labels, uint * labelsLen, char *label, Bool eventQuirk)
+// uint32_t rcoxml_add_label(rRCOFile* rco, char* label) {
+uint32_t
+rcoxml_add_label (char **labels, uint32_t * labelsLen, char *label, uint8_t eventQuirk)
{
// first, see if we already have this label
- uint p = 0;
+ uint32_t p = 0;
while (p < *labelsLen && (*labels)[p]) {
if (!strcmp (*labels + p, label))
}
// don't have it? add it
- uint curLen = *labelsLen;
- uint labelLen = strlen (label) + 1;
+ uint32_t curLen = *labelsLen;
+ uint32_t labelLen = strlen (label) + 1;
if (eventQuirk) {
// TODO:
}
- uint newLen = curLen + labelLen;
+ uint32_t newLen = curLen + labelLen;
newLen = ALIGN_TO_4 (newLen);
*labelsLen = newLen;
/*
- * uint curLen = rco->labelsLen; uint newLen = rco->labelsLen + strlen(label)
+ * uint32_t curLen = rco->labelsLen; uint32_t newLen = rco->labelsLen + strlen(label)
* + 1;
*
* rco->labels = (char*)realloc(rco->labels, newLen); strcpy(curLen, label);
return curLen;
}
-uint
-rcoxml_add_label_reordering (char *newLabels, uint * labelPos, char *label)
+uint32_t
+rcoxml_add_label_reordering (char *newLabels, uint32_t * labelPos, char *label)
{
// first, see if we already have this label
- uint p = 0;
+ uint32_t p = 0;
while (p < *labelPos && newLabels[p]) {
if (!strcmp (newLabels + p, label))
// don't have it? add it
strcpy (newLabels + *labelPos, label);
- uint curPos = *labelPos;
+ uint32_t curPos = *labelPos;
*labelPos += strlen (label) + 1;
*labelPos = ALIGN_TO_4 (*labelPos);
}
void
-rcoxml_reorder_labels (char *newLabels, uint * labelPos, rRCOFile * rco,
+rcoxml_reorder_labels (char *newLabels, uint32_t * labelPos, rRCOFile * rco,
rRCOEntry * entry)
{
- uint i;
+ uint32_t i;
if (entry->labelOffset != RCO_NULL_PTR)
entry->labelOffset =
if (entry->type <= RCO_OBJ_EXTRA_LEN_NUM &&
RCO_OBJ_EXTRA_LEN[entry->type] != -1) {
- uint i = 0, i2 = 0;
+ uint32_t i = 0, i2 = 0;
// work out the length of this thing, lol
- entry->extraLen = RCO_OBJ_EXTRA_LEN[entry->type] * sizeof (uint32);
- for (i = 0, i2 = 0; i < (uint) RCO_OBJ_EXTRA_LEN[entry->type]; i++, i2++) {
+ entry->extraLen = RCO_OBJ_EXTRA_LEN[entry->type] * sizeof (uint32_t);
+ for (i = 0, i2 = 0; i < (uint32_t) RCO_OBJ_EXTRA_LEN[entry->type]; i++, i2++) {
if (RCO_OBJ_IS_REF (entry->type, i2)) {
- entry->extraLen -= 2 * sizeof (uint32);
+ entry->extraLen -= 2 * sizeof (uint32_t);
entry->extraLen += sizeof (rRCORef);
i++;
}
}
entry->extra = malloc (entry->extraLen);
- uint8 *extra = (uint8 *) entry->extra;
+ uint8_t *extra = (uint8_t *) entry->extra;
memset (extra, 0, entry->extraLen);
for (i = 0, i2 = 0; (int) i < RCO_OBJ_EXTRA_LEN[entry->type]; i++, i2++) {
- Bool isRef = RCO_OBJ_IS_REF (entry->type, i2);
+ uint8_t isRef = RCO_OBJ_IS_REF (entry->type, i2);
xmlChar *val = NULL;
if (isRef)
((rRCORef *) extra)->type = RCO_REF_NONE;
else
- *(uint32 *) extra = 0;
+ *(uint32_t *) extra = 0;
} else {
if (isRef) {
// refs may need fixing later on
* useful right now ((rRCORef*)extra)->type = RCO_REF_NONE;
* add_ref_to_fix(fixes, , (rRCORef*)extra); */
} else {
- *(uint32 *) extra = rcoxml_parse_value ((char *) val);
+ *(uint32_t *) extra = rcoxml_parse_value ((char *) val);
}
xmlFree (val);
}
extra += sizeof (rRCORef);
i++;
} else
- extra += sizeof (uint32);
+ extra += sizeof (uint32_t);
}
} else {
// TODO: handle unknown types
if (entry->type <= RCO_ANIM_EXTRA_LEN_NUM &&
RCO_ANIM_EXTRA_LEN[entry->type] != -1) {
- uint i = 0, i2 = 0;
+ uint32_t i = 0, i2 = 0;
// work out the length of this thing, lol
- entry->extraLen = RCO_ANIM_EXTRA_LEN[entry->type] * sizeof (uint32);
- for (i = 0, i2 = 0; i < (uint) RCO_ANIM_EXTRA_LEN[entry->type]; i++, i2++) {
+ entry->extraLen = RCO_ANIM_EXTRA_LEN[entry->type] * sizeof (uint32_t);
+ for (i = 0, i2 = 0; i < (uint32_t) RCO_ANIM_EXTRA_LEN[entry->type]; i++, i2++) {
if (RCO_ANIM_IS_REF (entry->type, i2)) {
- entry->extraLen -= 2 * sizeof (uint32);
+ entry->extraLen -= 2 * sizeof (uint32_t);
entry->extraLen += sizeof (rRCORef);
i++;
}
}
entry->extra = malloc (entry->extraLen);
- uint8 *extra = (uint8 *) entry->extra;
+ uint8_t *extra = (uint8_t *) entry->extra;
memset (extra, 0, entry->extraLen);
for (i = 0, i2 = 0; (int) i < RCO_ANIM_EXTRA_LEN[entry->type]; i++, i2++) {
- Bool isRef = RCO_ANIM_IS_REF (entry->type, i2);
+ uint8_t isRef = RCO_ANIM_IS_REF (entry->type, i2);
xmlChar *val = NULL;
if (isRef)
((rRCORef *) extra)->type = RCO_REF_NONE;
else
- *(uint32 *) extra = 0;
+ *(uint32_t *) extra = 0;
} else {
if (isRef) {
// refs may need fixing later on
* useful right now ((rRCORef*)extra)->type = RCO_REF_NONE;
* add_ref_to_fix(fixes, , (rRCORef*)extra); */
} else {
- *(uint32 *) extra = rcoxml_parse_value ((char *) val);
+ *(uint32_t *) extra = rcoxml_parse_value ((char *) val);
}
xmlFree (val);
}
extra += sizeof (rRCORef);
i++;
} else
- extra += sizeof (uint32);
+ extra += sizeof (uint32_t);
}
} else {
// TODO: handle unknown types
* void parse_anim_extra(xmlNodePtr node, rRCOEntry* entry) {
*
* if(entry->type <= RCO_ANIM_EXTRA_LEN_NUM && RCO_ANIM_EXTRA_LEN[entry->type]
- * != -1) { uint i = 0;
+ * != -1) { uint32_t i = 0;
*
- * entry->extraLen = 0; for(i=0, i2=0; i<(uint)RCO_ANIM_EXTRA_LEN[entry->type];
+ * entry->extraLen = 0; for(i=0, i2=0; i<(uint32_t)RCO_ANIM_EXTRA_LEN[entry->type];
* i++, i2++) { if(RCO_ANIM_IS_REF(entry->type, i2)) { entry->extraLen +=
- * sizeof(rRCORef); i++; } else entry->extraLen += sizeof(uint32); }
+ * sizeof(rRCORef); i++; } else entry->extraLen += sizeof(uint32_t); }
*
* //if(RCO_ANIM_EXTRA_REFS[entry->type]) { // entry->extraLen =
- * (RCO_ANIM_EXTRA_LEN[entry->type]-2) * sizeof(uint32) + sizeof(rRCORef); //}
+ * (RCO_ANIM_EXTRA_LEN[entry->type]-2) * sizeof(uint32_t) + sizeof(rRCORef); //}
* else { // entry->extraLen = RCO_ANIM_EXTRA_LEN[entry->type] *
- * sizeof(uint32); //}
+ * sizeof(uint32_t); //}
*
- * entry->extra = malloc(entry->extraLen); uint8* extra = (uint8*)entry->extra;
+ * entry->extra = malloc(entry->extraLen); uint8_t* extra = (uint8_t*)entry->extra;
* memset(extra, 0, entry->extraLen);
*
- * uint entryLen = (uint)RCO_ANIM_EXTRA_LEN[entry->type];
+ * uint32_t entryLen = (uint32_t)RCO_ANIM_EXTRA_LEN[entry->type];
*
* if(RCO_ANIM_EXTRA_REFS[entry->type]) { xmlChar* val = NULL; if(entry->type ==
* RCO_ANIM_TYPE_EVENT) val = xmlGetProp(node, _X("event")); else val =
* Missing attribute '%s', defaulting to 0 / nothing.", node->line,
* RCO_ANIM_EXTRA_NAMES[entry->type][i]); } else { warning("[line %d] Missing
* attribute (index %d), defaulting to 0 / nothing.", node->line, i); // TODO:
- * better message } *(uint32*)extra = 0; } else { *(uint32*)extra =
+ * better message } *(uint32_t*)extra = 0; } else { *(uint32_t*)extra =
* rcoxml_parse_value((char*)val); xmlFree(val); }
*
- * extra += sizeof(uint32); } } else { // TODO: handle unknown types } } */
+ * extra += sizeof(uint32_t); } } else { // TODO: handle unknown types } } */
// TODO: this somewhat mixes normal vals with refs (not optimal) - may wish to
// do something about this
xmlChar *
-rcoxml_get_unknown_attrib (xmlNodePtr node, uint num)
+rcoxml_get_unknown_attrib (xmlNodePtr node, uint32_t num)
{
xmlChar *ret = NULL;
char n[30];
}
// parse object/anim attrib values
-uint32
+uint32_t
rcoxml_parse_value (char *s)
{
- uint32 retI = 0;
+ uint32_t retI = 0;
float retF = 0;
- if (sscanf (s, "0x%x", (uint *) & retI))
+ if (sscanf (s, "0x%x", (uint32_t *) & retI))
return retI;
retF = strtof (s, NULL);
- memcpy (&retI, &retF, sizeof (uint32));
+ memcpy (&retI, &retF, sizeof (uint32_t));
return retI;
}
-Bool
+uint8_t
rcoxml_parse_ref (char *val, rRCORef * out)
{
// defaults
void
rcoxml_fix_refs (rRCOEntry * entry, rRCOFile * rco)
{
- uint i = 0, i2 = 0;
+ uint32_t i = 0, i2 = 0;
if ((entry->id == RCO_TABLE_OBJ && entry->type > 0 &&
entry->type <= RCO_OBJ_EXTRA_LEN_NUM &&
|| (entry->id == RCO_TABLE_ANIM && entry->type > 1 &&
entry->type <= RCO_ANIM_EXTRA_LEN_NUM &&
RCO_ANIM_EXTRA_LEN[entry->type] != -1)) {
- uint8 *extra = (uint8 *) entry->extra;
+ uint8_t *extra = (uint8_t *) entry->extra;
- uint len;
+ uint32_t len;
if (entry->id == RCO_TABLE_OBJ)
len = RCO_OBJ_EXTRA_LEN[entry->type];
extra += sizeof (rRCORef);
i++;
} else
- extra += sizeof (uint32);
+ extra += sizeof (uint32_t);
}
/*
* if(entry->id == RCO_TABLE_OBJ) { for(i=0, i2=0;
* (int)i<RCO_OBJ_EXTRA_LEN[entry->type]; i++, i2++) {
* if(RCO_OBJ_IS_REF(entry->type, i2)) { rcoxml_fix_ref((rRCORef*)extra,
- * rco); extra += sizeof(rRCORef); i++; } else extra += sizeof(uint32); }
+ * rco); extra += sizeof(rRCORef); i++; } else extra += sizeof(uint32_t); }
*
* } else { // anim entries if(RCO_ANIM_EXTRA_REFS[entry->type]) {
* rcoxml_fix_ref((rRCORef*)extra, rco); } } */
// fixes the pointer of a reference if it needs one
// (current pointer needs to be pointing at label name)
-Bool
+uint8_t
rcoxml_fix_ref (rRCORef * ref, rRCOFile * rco)
{
if (ref->type == RCO_REF_IMG || ref->type == RCO_REF_MODEL ||
}
void
-rcoxml_fix_ptrs (rRCOEntry *** sect, uint * sectCnt, rRCOFile * rco,
+rcoxml_fix_ptrs (rRCOEntry *** sect, uint32_t * sectCnt, rRCOFile * rco,
const char *text)
{
- uint textLen = strlen (text);
+ uint32_t textLen = strlen (text);
*sectCnt = 0;
if (!textLen) {
strcpy (tmpText, text);
- uint i;
+ uint32_t i;
/*
* for(i=0; i<textLen; i++) if(tmpText[i] == ',') { (*sectCnt)++; tmpText[i]
while (isspace (tmpTextPtr[0]))
tmpTextPtr++; // skip whitespace
strtrimr (tmpTextPtr);
- uint labelLen = strlen (tmpTextPtr);
+ uint32_t labelLen = strlen (tmpTextPtr);
if (labelLen) {
*entryPtr = find_entry_from_label (&(rco->tblMain), tmpTextPtr);
// takes a comma separated string, replaces commas with nullchars and returns
// number of items in the list
-uint
+uint32_t
split_comma_list (char *s)
{
- uint cnt = 1;
- uint i;
- uint sLen = strlen (s);
+ uint32_t cnt = 1;
+ uint32_t i;
+ uint32_t sLen = strlen (s);
if (!s[0])
return 0; // empty string
char *
strtrimr (char *in)
{
- uint len = strlen (in);
+ uint32_t len = strlen (in);
while (len--)
if (!isspace (in[len]))
char *
expand_fname_to_fmt (char *in, char type)
{
- uint newSz = strlen (in) + 1;
+ uint32_t newSz = strlen (in) + 1;
char *p = in;
while ((p = strchr (p, '*'))) {
prevP = p;
}
- uint ppLen = strlen (prevP);
+ uint32_t ppLen = strlen (prevP);
if (ppLen) {
memcpy (newStrPtr, prevP, ppLen);
return newStr;
}
-Bool
+uint8_t
parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry)
{
xmlDocPtr doc;
xmlNodePtr node;
int i;
- Bool bValidDoc = FALSE;
+ uint8_t bValidDoc = FALSE;
rRCOTextEntry *te = (rRCOTextEntry *) entry->extra;
if (!(doc = xmlParseFile (fn))) {
if (te->numIndexes) {
void *textBuffer = NULL;
- uint curPos = 0;
- uint fmt = te->format;
+ uint32_t curPos = 0;
+ uint32_t fmt = te->format;
char icDestFmt[8];
- uint charWidth = 2;
+ uint32_t charWidth = 2;
make_iconv_charset (icDestFmt, fmt, rco->eSwap);
if (fmt == RCO_TEXT_FMT_UTF32) {
n = np->xmlChildrenNode->content;
if (fmt == RCO_TEXT_FMT_UTF8) {
te->indexes[i].length = xmlStrlen (n) + 1 /* null */ ;
- if ((*(uint32 *) n & 0xFFFFFF) == UTF8_BOM)
+ if ((*(uint32_t *) n & 0xFFFFFF) == UTF8_BOM)
te->indexes[i].length -= 3;
} else {
// xmlUTF8Strlen used because libxml2 will guarantee src is UTF8
te->indexes[i].length =
(xmlUTF8Strlen (n) + 1 /* null */ ) * charWidth;
- if ((*(uint32 *) n & 0xFFFFFF) == UTF8_BOM) { // fix for
+ if ((*(uint32_t *) n & 0xFFFFFF) == UTF8_BOM) { // fix for
// older
// versions of
// rcomage - if
}
}
if (te->indexes[i].length > 2) {
- uint contentLen = xmlStrlen (n), outBufLen =
+ uint32_t contentLen = xmlStrlen (n), outBufLen =
te->indexes[i].length;
textBuffer =
tbPtr += curPos;
// first get rid of BOM if we have one (earlier versions of
// rcomage)
- /* if((fmt == RCO_TEXT_FMT_UTF32 && *(uint32*)n == UTF32_BOM)
- * ||(fmt == RCO_TEXT_FMT_UTF16 && *(uint16*)n == UTF16_BOM)
- * ||(fmt == RCO_TEXT_FMT_UTF8 && (*(uint32*)n & 0x00FFFFFF) ==
+ /* if((fmt == RCO_TEXT_FMT_UTF32 && *(uint32_t*)n == UTF32_BOM)
+ * ||(fmt == RCO_TEXT_FMT_UTF16 && *(uint16_t*)n == UTF16_BOM)
+ * ||(fmt == RCO_TEXT_FMT_UTF8 && (*(uint32_t*)n & 0x00FFFFFF) ==
* UTF8_BOM)) { */
- if ((*(uint32 *) n & 0xFFFFFF) == UTF8_BOM) {
+ if ((*(uint32_t *) n & 0xFFFFFF) == UTF8_BOM) {
char bom[4];
char *bomPtr = bom;
- uint bomLen =
+ uint32_t bomLen =
(fmt == RCO_TEXT_FMT_UTF32 ? 4 : (fmt ==
RCO_TEXT_FMT_UTF8 ? 3 : 2));
iconv (ic, (char **) (&n), (size_t *) (&contentLen),
#define IMP(a,b) (!(a) || (b)) // logical implication, ie, a implies b
-void xmlwrite_entry (rRCOEntry * entry, uint depth, rRCOFile * rco, FILE * fp,
- char *textDir, Bool textXmlOut, int sndDumped, Bool vsmxConv);
-void xmlwrite_entry_extra_object (uint16 type, uint8 * info, rRCOFile * rco,
+void xmlwrite_entry (rRCOEntry * entry, uint32_t depth, rRCOFile * rco, FILE * fp,
+ char *textDir, uint8_t textXmlOut, int sndDumped, uint8_t vsmxConv);
+void xmlwrite_entry_extra_object (uint16_t type, uint8_t * info, rRCOFile * rco,
FILE * fp);
-void xmlwrite_entry_extra_anim (uint16 type, uint8 * info, rRCOFile * rco,
+void xmlwrite_entry_extra_anim (uint16_t type, uint8_t * info, rRCOFile * rco,
FILE * fp);
void xml_fputref (rRCORef * ref, rRCOFile * rco, FILE * fp);
void rcoxml_fput_escstr (FILE * fp, char *str);
-Bool
-write_xml (rRCOFile * rco, FILE * fp, char *textDir, Bool textXmlOut,
- int sndDumped, Bool vsmxConv)
+uint8_t
+write_xml (rRCOFile * rco, FILE * fp, char *textDir, uint8_t textXmlOut,
+ int sndDumped, uint8_t vsmxConv)
{
fputs ("<?xml version=\"1.0\" encoding=\"iso-8859-1\"?>\n", fp);
}
void
-xmlwrite_entry (rRCOEntry * entry, uint depth, rRCOFile * rco, FILE * fp,
- char *textDir, Bool textXmlOut, int sndDumped, Bool vsmxConv)
+xmlwrite_entry (rRCOEntry * entry, uint32_t depth, rRCOFile * rco, FILE * fp,
+ char *textDir, uint8_t textXmlOut, int sndDumped, uint8_t vsmxConv)
{
- uint i;
+ uint32_t i;
char dummy[50] = "\0";
char *tagName = dummy;
if (entry->id < RCOXML_TABLE_TAGS_NUM) {
- uint maxType = 0;
+ uint32_t maxType = 0;
while (RCOXML_TABLE_TAGS[entry->id][maxType][0])
maxType++;
fputc ('\t', fp);
fprintf (fp, "<%s", tagName);
- Bool isMainTable = (entry->type == 0 || (entry->id == RCO_TABLE_MAIN &&
+ uint8_t isMainTable = (entry->type == 0 || (entry->id == RCO_TABLE_MAIN &&
entry->type == 1));
// if(isMainTable)
// fputs("Table", fp);
// extra attribs
if (isMainTable) {
/*
- * // pointer ordering uint numPtrs = 0; void* ptrs; switch(entry->id) {
+ * // pointer ordering uint32_t numPtrs = 0; void* ptrs; switch(entry->id) {
* case RCO_TABLE_TEXT: ptrs = rco->ptrText; numPtrs = rco->numPtrText;
* break; case RCO_TABLE_IMG: ptrs = rco->ptrImg; numPtrs = rco->numPtrImg;
* break; case RCO_TABLE_SOUND: ptrs = rco->ptrSound; numPtrs =
* rco->numPtrSound; break; case RCO_TABLE_MODEL: ptrs = rco->ptrModel;
* numPtrs = rco->numPtrModel; break; case RCO_TABLE_OBJ: ptrs =
* rco->ptrObj; numPtrs = rco->numPtrObj; break; case RCO_TABLE_ANIM: ptrs =
- * rco->ptrAnim; numPtrs = rco->numPtrAnim; break; } if(numPtrs) { uint j;
+ * rco->ptrAnim; numPtrs = rco->numPtrAnim; break; } if(numPtrs) { uint32_t j;
* fputs(" ptrorder=\"", fp); for(i=0; i<numPtrs; i++) { if(i) fputs(",",
* fp);
*
rcoxml_int_to_text (te->format, RCOXML_TABLE_TEXT_FMT, tmp);
fprintf (fp, " format=\"%s\"", tmp);
if (te->numIndexes && !textXmlOut) { // write text labels
- uint j;
+ uint32_t j;
fputs (" entries=\"", fp);
for (i = 0; i < te->numIndexes; i++) {
}
break;
case RCO_TABLE_OBJ:
- xmlwrite_entry_extra_object (entry->type, (uint8 *) entry->extra, rco,
+ xmlwrite_entry_extra_object (entry->type, (uint8_t *) entry->extra, rco,
fp);
break;
case RCO_TABLE_ANIM:
- xmlwrite_entry_extra_anim (entry->type, (uint8 *) entry->extra, rco,
+ xmlwrite_entry_extra_anim (entry->type, (uint8_t *) entry->extra, rco,
fp);
break;
}
}
void
-xmlwrite_entry_extra_object (uint16 type, uint8 * info, rRCOFile * rco,
+xmlwrite_entry_extra_object (uint16_t type, uint8_t * info, rRCOFile * rco,
FILE * fp)
{
// increase twice for a
// reference
// is this entry a reference?
- Bool isRef = RCO_OBJ_IS_REF (type, i2);
+ uint8_t isRef = RCO_OBJ_IS_REF (type, i2);
// if(i2) fputc(' ', fp); // space if not first param
fputc (' ', fp);
if (RCO_OBJ_EXTRA_TYPES[type][i2] == RCO_OBJ_EXTRA_TYPE_FLOAT)
fprintf (fp, "%g", *(float *) info);
else
- fprintf (fp, "0x%x", *(uint32 *) info);
+ fprintf (fp, "0x%x", *(uint32_t *) info);
- info += sizeof (uint32); // or sizeof(float)
+ info += sizeof (uint32_t); // or sizeof(float)
}
fputs ("\"", fp);
}
void
-xmlwrite_entry_extra_anim (uint16 type, uint8 * info, rRCOFile * rco, FILE * fp)
+xmlwrite_entry_extra_anim (uint16_t type, uint8_t * info, rRCOFile * rco, FILE * fp)
{
int numEntries = RCO_ANIM_EXTRA_LEN[type];
// increase twice for a
// reference
// is this entry a reference?
- Bool isRef = RCO_ANIM_IS_REF (type, i2);
+ uint8_t isRef = RCO_ANIM_IS_REF (type, i2);
// if(i2) fputc(' ', fp); // space if not first param
fputc (' ', fp);
if (RCO_ANIM_EXTRA_TYPES[type][i2] == RCO_OBJ_EXTRA_TYPE_FLOAT)
fprintf (fp, "%g", *(float *) info);
else
- fprintf (fp, "0x%x", *(uint32 *) info);
+ fprintf (fp, "0x%x", *(uint32_t *) info);
- info += sizeof (uint32); // or sizeof(float)
+ info += sizeof (uint32_t); // or sizeof(float)
}
fputs ("\"", fp);
}
/*
- * void xmlwrite_entry_extra_anim(uint16 type, uint8* info, rRCOFile* rco,
+ * void xmlwrite_entry_extra_anim(uint16_t type, uint8_t* info, rRCOFile* rco,
* FILE* fp) { int numEntries = RCO_ANIM_EXTRA_LEN[type]; int i;
*
* if(numEntries < 1) return; // TODO: handle unknown anim types?
* break; } fprintf(fp, "%d", i); } fputs("=\"", fp);
*
* if(RCO_ANIM_EXTRA_TYPES[type][i] == RCO_OBJ_EXTRA_TYPE_FLOAT) fprintf(fp,
- * "%g", *(float*)info); else fprintf(fp, "0x%x", *(uint32*)info);
+ * "%g", *(float*)info); else fprintf(fp, "0x%x", *(uint32_t*)info);
*
- * info += sizeof(uint32); // or sizeof(float)
+ * info += sizeof(uint32_t); // or sizeof(float)
*
* fputs("\"", fp); } } */
void
xml_fputref (rRCORef * ref, rRCOFile * rco, FILE * fp)
{
- Bool unkType = FALSE;
+ uint8_t unkType = FALSE;
switch (ref->type) {
case RCO_REF_EVENT:
}
void
-rcoxml_int_to_text (uint in, const RcoTableMap map, char *out)
+rcoxml_int_to_text (uint32_t in, const RcoTableMap map, char *out)
{
- uint len = 0;
+ uint32_t len = 0;
// determine length of map
while (map[len][0])
projects / console / RCOMage.git / commitdiff