From 285430ca6996cdf5cd1ccff8f7d72bc1ce0657dc Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Sun, 9 Jan 2011 08:15:09 -0500 Subject: [PATCH] Use the proper stdint type variables instead of reduced typedefs --- configscan.c | 4 +- configscan.h | 4 +- general.c | 36 +++---- general.h | 36 +++---- globdefs.c | 8 +- main.c | 52 +++++------ rcodump.c | 90 +++++++++--------- rcodump.h | 12 +-- rcofile.h | 156 +++++++++++++++---------------- rcomain.c | 30 +++--- rcomain.h | 168 ++++++++++++++++----------------- rcoreader.c | 152 +++++++++++++++--------------- rcowriter.c | 260 +++++++++++++++++++++++++-------------------------- vaghandler.c | 94 +++++++++---------- vaghandler.h | 4 +- vsmx.c | 58 ++++++------ vsmx.h | 18 ++-- xml.h | 10 +- xmlread.c | 252 ++++++++++++++++++++++++------------------------- xmlwrite.c | 62 ++++++------ 20 files changed, 748 insertions(+), 758 deletions(-) diff --git a/configscan.c b/configscan.c index 698a46d..ede2df4 100644 --- a/configscan.c +++ b/configscan.c @@ -162,7 +162,7 @@ configLoadMiscmap (void) } void -configLoadObjmap (Bool ps3) +configLoadObjmap (uint8_t ps3) { char from[30] = "objattribdef-psp.ini"; @@ -239,7 +239,7 @@ configLoadObjmap (Bool ps3) } void -configLoadAnimmap (Bool ps3) +configLoadAnimmap (uint8_t ps3) { char from[30] = "animattribdef-psp.ini"; diff --git a/configscan.h b/configscan.h index f1e9dd4..9802a86 100644 --- a/configscan.h +++ b/configscan.h @@ -7,7 +7,7 @@ extern char *configDir; 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 diff --git a/general.c b/general.c index 6f47616..385f3c6 100644 --- a/general.c +++ b/general.c @@ -9,8 +9,8 @@ #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) { @@ -21,7 +21,7 @@ zlib_compress (void *src, uint srcLen, void *dest, uint destLen, int level, 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; @@ -55,7 +55,7 @@ zlib_compress (void *src, uint srcLen, void *dest, uint destLen, int level, 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 { @@ -107,8 +107,8 @@ zlib_uncompress (void *dest, unsigned int destLen, const void *src, return ret; } -uint -zlib_unpacked_size (void *src, uint srcLen) +uint32_t +zlib_unpacked_size (void *src, uint32_t srcLen) { z_stream s; @@ -125,7 +125,7 @@ zlib_unpacked_size (void *src, uint srcLen) 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) { @@ -147,8 +147,8 @@ zlib_unpacked_size (void *src, uint srcLen) 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 @@ -185,7 +185,7 @@ rlz_compress (void *src, uint srcLen, void *dest, uint destLen, int mode) } } -Bool +uint8_t file_exists (char *fn) { // our deetection routine is weird - just tries to open the file @@ -199,7 +199,7 @@ file_exists (char *fn) return FALSE; } -uint +uint32_t filesize (const char *fn) { FILE *fp = fopen (fn, "rb"); @@ -207,7 +207,7 @@ filesize (const char *fn) if (!fp) return 0; fseek (fp, 0, SEEK_END); - uint f = ftell (fp); + uint32_t f = ftell (fp); fclose (fp); @@ -215,8 +215,8 @@ filesize (const char *fn) } // 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; @@ -231,8 +231,8 @@ find_larger_prime (uint in) } } -Bool -is_prime (uint in) +uint8_t +is_prime (uint32_t in) { if (in < 12) { // need this buffer as "lim" (below) may // underflow @@ -242,8 +242,8 @@ is_prime (uint in) 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) diff --git a/general.h b/general.h index 475b89b..61cf62d 100644 --- a/general.h +++ b/general.h @@ -11,16 +11,12 @@ #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) @@ -29,7 +25,7 @@ typedef int Bool; #include -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); } @@ -52,31 +48,25 @@ extern Bool quietMode; // #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); diff --git a/globdefs.c b/globdefs.c index c675f1f..75ff52f 100644 --- a/globdefs.c +++ b/globdefs.c @@ -4,7 +4,7 @@ // 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; @@ -12,9 +12,9 @@ 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 }; @@ -40,6 +40,6 @@ RcoTableMap RCOXML_TABLE_SOUND_FMT = NULL; RcoTagMap RCOXML_TABLE_TAGS = NULL; -uint RCOXML_TABLE_TAGS_NUM; +uint32_t RCOXML_TABLE_TAGS_NUM; RcoTableMap RCOXML_TABLE_NAMES = NULL; diff --git a/main.c b/main.c index 6b9c919..6fe4ae6 100644 --- a/main.c +++ b/main.c @@ -38,13 +38,13 @@ int main_vagenc (void); 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) @@ -228,7 +228,7 @@ main_help () " The following options only apply for extracting text resources.\n" " --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", @@ -357,7 +357,7 @@ main_dump (void) char *sRcoFile = NULL; char *sXmlFile = NULL; - Bool sTextOutput = FALSE; + uint8_t sTextOutput = FALSE; // char curPath[] = "."; char *sResDir = NULL; @@ -369,8 +369,8 @@ main_dump (void) // char* sConvGim = NULL; RcoDumpGimconvOpts gimconvOpts; - Bool sConvVag = FALSE; - Bool sConvVsmx = FALSE; + uint8_t sConvVag = FALSE; + uint8_t sConvVsmx = FALSE; int i; @@ -420,7 +420,7 @@ main_dump (void) } // 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 || @@ -532,8 +532,8 @@ main_dump (void) 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; @@ -608,17 +608,17 @@ main_dump (void) 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); @@ -750,9 +750,9 @@ main_dump (void) 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; @@ -844,7 +844,7 @@ main_dump (void) 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 *)); @@ -880,7 +880,7 @@ main_dump (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--) @@ -899,8 +899,8 @@ main_dump (void) 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, ""); @@ -919,7 +919,7 @@ main_dump (void) } // 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'; @@ -927,7 +927,7 @@ main_dump (void) 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; @@ -962,7 +962,7 @@ main_dump (void) 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); @@ -1003,7 +1003,7 @@ main_dump (void) VsmxMem *vm = readVSMX (fin); fclose (fin); - Bool success = FALSE; + uint8_t success = FALSE; if (vm) { info ("Writing decoded output..."); @@ -1069,7 +1069,7 @@ main_dump (void) } } - void retrieve_from_opts (Bool warnUnk, int num, ...) { + void retrieve_from_opts (uint8_t warnUnk, int num, ...) { int i, j; va_list ap; @@ -1083,7 +1083,7 @@ main_dump (void) 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]; diff --git a/rcodump.c b/rcodump.c index 4a3fbf1..2efe3f6 100644 --- a/rcodump.c +++ b/rcodump.c @@ -25,9 +25,9 @@ #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) { @@ -37,8 +37,8 @@ dump_resource (char *dest, rRCOEntry * entry, OutputDumpFunc outputfunc, 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; @@ -51,13 +51,13 @@ dump_resource (char *dest, rRCOEntry * entry, OutputDumpFunc outputfunc, 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); @@ -71,7 +71,7 @@ dump_output_data (char *dest, void *buf, rRCOEntry * entry, void *arg) return FALSE; } -Bool +uint8_t dump_output_wav (char *dest, void *buf, rRCOEntry * entry, void *arg) { int i; @@ -80,7 +80,7 @@ dump_output_wav (char *dest, void *buf, rRCOEntry * entry, void *arg) 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]; @@ -93,14 +93,14 @@ dump_output_wav (char *dest, void *buf, rRCOEntry * entry, void *arg) 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) { @@ -115,26 +115,26 @@ dump_output_gimconv (char *dest, void *buf, rRCOEntry * entry, void *arg) 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); @@ -189,7 +189,7 @@ dump_output_gimconv (char *dest, void *buf, rRCOEntry * entry, void *arg) #endif } -Bool +uint8_t dump_output_vsmxdec (char *dest, void *buf, rRCOEntry * entry, void *arg) { VsmxMem *vm = readVSMXMem (buf); @@ -219,7 +219,7 @@ dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, return; char fullOutName[MAX_FILENAME_LEN]; - uint extMapLen = 0; + uint32_t extMapLen = 0; char dat[5] = "dat"; strcpy (fullOutName, pathPrefix); @@ -229,14 +229,14 @@ dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, 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; @@ -255,7 +255,7 @@ dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, 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; @@ -291,7 +291,7 @@ dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, 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]; @@ -327,7 +327,7 @@ dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, * 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 += @@ -350,8 +350,8 @@ dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, } 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; @@ -360,7 +360,7 @@ dump_text_resources (char *labels, rRCOEntry * parent, Bool writeHeader, 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) { @@ -435,14 +435,14 @@ dump_text_resources (char *labels, rRCOEntry * parent, Bool writeHeader, 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) { @@ -467,17 +467,17 @@ dump_text_resources (char *labels, rRCOEntry * parent, Bool writeHeader, } 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); @@ -490,7 +490,7 @@ dump_text_resources (char *labels, rRCOEntry * parent, Bool writeHeader, 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)); @@ -501,22 +501,22 @@ dump_text_resources (char *labels, rRCOEntry * parent, Bool writeHeader, 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, @@ -618,7 +618,7 @@ compile_vagconv_map (rRCOFile * rco, rRCOEntry * entry, void *arg) 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, ""); @@ -633,7 +633,7 @@ compile_vagconv_map (rRCOFile * rco, rRCOEntry * entry, void *arg) 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; @@ -676,7 +676,7 @@ compile_wavcheck_map (rRCOFile * rco, rRCOEntry * entry, void *arg) get_label_from_offset (rco->labels, entry->labelOffset)); } -Bool +uint8_t exec_gimconv (char *cmd, char *src, char *dest, char *extFlags) { #ifdef WIN32 diff --git a/rcodump.h b/rcodump.h index 965ca69..1892628 100644 --- a/rcodump.h +++ b/rcodump.h @@ -2,7 +2,7 @@ #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; @@ -10,14 +10,14 @@ typedef struct { 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); diff --git a/rcofile.h b/rcofile.h index 7ebc9b0..78bc0b9 100644 --- a/rcofile.h +++ b/rcofile.h @@ -18,80 +18,80 @@ #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 @@ -115,15 +115,15 @@ PACK_STRUCT (RCOVSMXEntry, { #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 @@ -138,42 +138,42 @@ PACK_STRUCT (RCOTextIndex, { #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 @@ -213,8 +213,8 @@ PACK_STRUCT (RCOFontEntry, { #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 @@ -229,20 +229,20 @@ PACK_STRUCT (RCOReference, { #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 diff --git a/rcomain.c b/rcomain.c index 56e0c68..df1a4f1 100644 --- a/rcomain.c +++ b/rcomain.c @@ -3,7 +3,7 @@ #include #include "rcomain.h" -Bool suppressDecompWarnings = FALSE; +uint8_t suppressDecompWarnings = FALSE; void free_rco (rRCOFile * f) @@ -28,7 +28,7 @@ rco_map_func (rRCOFile * rco, rRCOEntry * parent, void *arg, } char * -get_label_from_offset (char *labels, uint labelOffset) +get_label_from_offset (char *labels, uint32_t labelOffset) { static char labelBuf[255]; @@ -50,7 +50,7 @@ get_label_from_offset (char *labels, uint labelOffset) * 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)); } } @@ -77,7 +77,7 @@ rco_fix_decomp_sizes (rRCOFile * rco, rRCOEntry * entry) 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 && @@ -107,7 +107,7 @@ rco_fix_decomp_sizes (rRCOFile * rco, rRCOEntry * entry) } void * -read_resource (rRCOEntry * entry, uint * outLen) +read_resource (rRCOEntry * entry, uint32_t * outLen) { char *bufferMid; @@ -140,7 +140,7 @@ read_resource (rRCOEntry * entry, uint * outLen) 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)); @@ -245,10 +245,10 @@ read_resource (rRCOEntry * entry, uint * outLen) 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) @@ -264,7 +264,7 @@ make_sorted_list_of_subentries (rRCOEntry * parent, 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; @@ -300,7 +300,7 @@ find_text_from_label (char *labels, rRCOTextEntry * textExtra, const char *s) 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)) @@ -310,7 +310,7 @@ find_text_from_label (char *labels, rRCOTextEntry * textExtra, const char *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) @@ -452,12 +452,12 @@ es_textComprInfo (TextComprInfo * tci) } 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) { @@ -471,8 +471,8 @@ es_extraObjAnim (Bool isObj, int type, void *data, Bool isPS3) 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) diff --git a/rcomain.h b/rcomain.h index ca96331..794c4ae 100644 --- a/rcomain.h +++ b/rcomain.h @@ -22,13 +22,13 @@ typedef struct { } 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) @@ -41,17 +41,17 @@ typedef struct __rRCOEntry { 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 @@ -60,13 +60,13 @@ typedef struct __rRCOEntry { } 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; @@ -77,15 +77,15 @@ typedef struct __rRCOFile { 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; @@ -99,40 +99,40 @@ typedef struct __rRCOFile { // 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) @@ -144,7 +144,7 @@ typedef char ((*RcoObjMap)[RCO_OBJMAP_SIZE][30]); 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) || \ @@ -175,7 +175,7 @@ extern RcoObjMap RCO_OBJ_EXTRA_NAMES; 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; @@ -184,12 +184,12 @@ 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 @@ -197,7 +197,7 @@ void *read_resource (rRCOEntry * entry, uint * outLen); 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 **)); @@ -205,7 +205,7 @@ rRCOEntry *find_entry_from_label (rRCOEntry * parent, const char *s); 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); @@ -217,7 +217,7 @@ void es_rcoImgModelEntry (RCOImgModelEntry * 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; @@ -234,7 +234,7 @@ PACK_STRUCT (RCOObjPos, { 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 @@ -245,70 +245,70 @@ PACK_STRUCT (RCOObjPos, { }); /* - * 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 @@ -318,23 +318,23 @@ PACK_STRUCT (RCOObjPos, { * 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 diff --git a/rcoreader.c b/rcoreader.c index 278f7f2..93240dd 100644 --- a/rcoreader.c +++ b/rcoreader.c @@ -13,35 +13,35 @@ // 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) @@ -273,7 +273,7 @@ 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); @@ -366,10 +366,10 @@ read_rco (char *fn) 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); \ } \ @@ -610,7 +610,7 @@ read_rco (char *fn) void read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, - Bool readSubEntries) + uint8_t readSubEntries) { data->offset = rcoread_ftell (rcoH); @@ -661,7 +661,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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 @@ -747,7 +747,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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); @@ -758,7 +758,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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); @@ -777,10 +777,10 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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; @@ -789,7 +789,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, // 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); @@ -801,7 +801,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, // image entry) if (!re.nextEntryOffset || re.nextEntryOffset < sizeof (RCOEntry) + rimeSize) - extraSize -= sizeof (uint32); + extraSize -= sizeof (uint32_t); } } else { error @@ -811,8 +811,8 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, } 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); @@ -824,10 +824,10 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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); @@ -836,17 +836,17 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, /* * // 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); @@ -895,11 +895,11 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, ((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 @@ -907,12 +907,12 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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 @@ -926,19 +926,19 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, // 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) @@ -977,7 +977,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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 && @@ -1014,7 +1014,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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 && @@ -1058,7 +1058,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, // process subentries if (readSubEntries && data->numSubentries) { - uint i; + uint32_t i; if (data->numSubentries > MAX_SUBENTRIES) { warning @@ -1067,7 +1067,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, 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; @@ -1129,7 +1129,7 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, // 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; @@ -1148,40 +1148,40 @@ find_entry_from_offset (rRCOEntry * parent, uint32 offset) 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)); @@ -1189,7 +1189,7 @@ fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray, 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; @@ -1236,8 +1236,8 @@ fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray, 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); } } @@ -1251,8 +1251,8 @@ fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray, 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; @@ -1262,13 +1262,13 @@ check_file_region (uint fSize, uint offset, uint size) } // 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; @@ -1278,7 +1278,7 @@ rco_fread (rRCOFile_readhelper * rcoH, void *buf, uint len) } } -uint +uint32_t rcoread_ftell (rRCOFile_readhelper * rcoH) { if (rcoH->tablesSize) { @@ -1289,7 +1289,7 @@ rcoread_ftell (rRCOFile_readhelper * rcoH) } 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) diff --git a/rcowriter.c b/rcowriter.c index 4db4e3e..3204d2c 100644 --- a/rcowriter.c +++ b/rcowriter.c @@ -13,51 +13,51 @@ typedef struct { 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 @@ -125,7 +125,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) 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 (); @@ -134,7 +134,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) 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) @@ -165,7 +165,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) 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); @@ -184,7 +184,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) 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; @@ -240,12 +240,12 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) { // write hashtable data /* { // special case for text hashes if(rco->numPtrText) { header.pTextPtrs - * = rcowrite_ftell(&rcoH); for(i=0; inumPtrText; i++) { uint32 + * = rcowrite_ftell(&rcoH); for(i=0; inumPtrText; 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; @@ -258,39 +258,39 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) 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; ioffset), 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, @@ -333,7 +333,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) // 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); @@ -354,21 +354,21 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) 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); @@ -377,7 +377,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) exit (1); } int comprMisalign = ci.lenPacked % 4; - uint packedLen = ci.lenPacked; + uint32_t packedLen = ci.lenPacked; if (rco->eSwap) es_headerComprInfo (&ci); @@ -386,7 +386,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) free (bufferOut); if (comprMisalign) { // 4 byte align - uint32 zero = 0; + uint32_t zero = 0; filewrite (rcoH.fp, &zero, 4 - comprMisalign); } @@ -406,13 +406,13 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) } } // 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; itblImage->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); } @@ -431,7 +431,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) || (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; @@ -446,11 +446,11 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) 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); @@ -493,11 +493,11 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) // 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; @@ -536,7 +536,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, (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; @@ -564,8 +564,8 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, 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) @@ -578,7 +578,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, if (entry->type == 1) { RCOTextEntry rte; rRCOTextEntry *src = (rRCOTextEntry *) entry->extra; - uint i; + uint32_t i; rte.lang = src->lang; rte.format = src->format; @@ -589,7 +589,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, // 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; @@ -629,7 +629,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, 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; @@ -648,16 +648,16 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, // 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; @@ -665,7 +665,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, 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; @@ -681,11 +681,11 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, 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) { @@ -697,8 +697,8 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, 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 @@ -707,7 +707,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, 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; @@ -740,7 +740,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, 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)); @@ -752,7 +752,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, } // subentries - uint nextOffset = 0; + uint32_t nextOffset = 0; rRCOEntry *rcoNode; for (rcoNode = entry->firstChild; rcoNode; rcoNode = rcoNode->next) { @@ -763,7 +763,7 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, // write nextEntryOffset if (!isLastSubentry) { - uint curPos = rcowrite_ftell (rcoH); + uint32_t curPos = rcowrite_ftell (rcoH); re.nextEntryOffset = curPos - fPos; rcowrite_fseek (rcoH, fPos); @@ -778,20 +778,20 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint parentOffset, } 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) @@ -803,14 +803,14 @@ rco_fwrite (rRCOFile_writehelper * rcoH, void *buffer, uint len) // 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 @@ -821,7 +821,7 @@ rcowrite_ftell (rRCOFile_writehelper * rcoH) } void -rcowrite_fseek (rRCOFile_writehelper * rcoH, uint pos) +rcowrite_fseek (rRCOFile_writehelper * rcoH, uint32_t pos) { // memory stuff if (rcoH->tables) @@ -833,13 +833,13 @@ rcowrite_fseek (rRCOFile_writehelper * rcoH, uint pos) // 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) @@ -853,13 +853,13 @@ rco_write_resource (FILE * dest, rRCOEntry * entry, uint destCompression, 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); @@ -876,7 +876,7 @@ rco_write_resource (FILE * dest, rRCOEntry * entry, uint destCompression, 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); @@ -897,12 +897,12 @@ rco_write_resource (FILE * dest, rRCOEntry * entry, uint destCompression, 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; * } * @@ -921,7 +921,7 @@ rco_write_resource (FILE * dest, rRCOEntry * entry, uint destCompression, // 4byte alignment if (packedSize % 4) { - uint32 zero = 0; + uint32_t zero = 0; filewrite (dest, &zero, 4 - (packedSize % 4)); } @@ -929,13 +929,13 @@ rco_write_resource (FILE * dest, rRCOEntry * entry, uint destCompression, 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; @@ -949,7 +949,7 @@ rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, TextComprInfo tci; char *textBuffer = NULL; - uint textBufferPos = 0; + uint32_t textBufferPos = 0; if (destCompression) { tci.lang = lang; @@ -958,10 +958,10 @@ rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, // 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; @@ -984,13 +984,13 @@ rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, 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); @@ -999,7 +999,7 @@ rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, 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); @@ -1026,7 +1026,7 @@ rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, free (bufferOut); if (tci.packedLen % 4) { - uint32 zero = 0; + uint32_t zero = 0; filewrite (rcoH->fp, &zero, 4 - (tci.packedLen % 4)); } @@ -1044,21 +1044,21 @@ rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, 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)); @@ -1107,13 +1107,13 @@ rco_write_fix_refs (rRCOEntry * parent, rRCOFile_writehelper * rcoH, // 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 { @@ -1124,11 +1124,11 @@ rco_write_fix_refs (rRCOEntry * parent, rRCOFile_writehelper * rcoH, } // 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); @@ -1140,40 +1140,40 @@ write_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * 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) + @@ -1184,18 +1184,18 @@ write_text_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry, } // 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)]; @@ -1211,10 +1211,10 @@ do_hashing (rRCOEntry * entry, rRCOFile * rco, Bool recurse, uint32 * hashTable, } } -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) { diff --git a/vaghandler.c b/vaghandler.c index 158e761..ee1a907 100644 --- a/vaghandler.c +++ b/vaghandler.c @@ -22,12 +22,12 @@ const double f[5][2] = { {0.0, 0.0}, #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]; }); @@ -45,24 +45,24 @@ PACK_STRUCT (VagChunk, { #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) { @@ -115,12 +115,12 @@ 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++) { @@ -138,7 +138,7 @@ vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData) 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; @@ -147,7 +147,7 @@ vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData) 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; } @@ -162,7 +162,7 @@ vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData) 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; @@ -177,7 +177,7 @@ vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData) } 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); @@ -201,9 +201,9 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) ("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 @@ -219,7 +219,7 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) 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) + @@ -237,9 +237,9 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) 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)); @@ -251,10 +251,10 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) 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 = @@ -299,7 +299,7 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) 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))) @@ -314,7 +314,7 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) // 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 = @@ -328,7 +328,7 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) 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; } @@ -339,11 +339,11 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) /* { 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"); } } } */ } } @@ -365,7 +365,7 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) } /* - * 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)); @@ -388,7 +388,7 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) * 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); @@ -399,15 +399,15 @@ wav2vag (const char *fWav, uint * len, void **vagData, const char *vagName) * - 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>=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); } } diff --git a/vaghandler.h b/vaghandler.h index d538e50..46e20ab 100644 --- a/vaghandler.h +++ b/vaghandler.h @@ -1,3 +1,3 @@ #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); diff --git a/vsmx.c b/vsmx.c index 6a1bea6..8250ec0 100644 --- a/vsmx.c +++ b/vsmx.c @@ -199,7 +199,7 @@ readVSMX (FILE * fp) { VSMXHeader header; - uint filePos; + uint32_t filePos; VsmxMem *out; fileread (fp, &header, sizeof (header)); @@ -255,7 +255,7 @@ readVSMX (FILE * fp) 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) { \ @@ -301,7 +301,7 @@ readVSMXMem (const void *in) { VSMXHeader *header = (VSMXHeader *) in; - uint filePos; + uint32_t filePos; VsmxMem *out; if (header->sig != VSMX_SIGNATURE || header->ver != VSMX_VERSION) { @@ -323,7 +323,7 @@ readVSMXMem (const void *in) // 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; @@ -351,13 +351,13 @@ readVSMXMem (const void *in) } \ \ 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) { \ @@ -460,19 +460,19 @@ writeVSMXMem (unsigned int *len, VsmxMem * in) 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; @@ -488,7 +488,7 @@ writeVSMXMem (unsigned int *len, VsmxMem * in) int VsmxDecode (VsmxMem * in, FILE * out) { - uint i; + uint32_t i; fputws (L"; Decoded VSMX file written by " APPNAME_VER "\n\n", out); @@ -527,7 +527,7 @@ VsmxDecode (VsmxMem * in, FILE * 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)); @@ -646,7 +646,7 @@ VsmxAddText (void **text, unsigned int **offs, unsigned int *textLen, } for (p = 0; p < *numText; p++) { - Bool cond; + uint8_t cond; if (charWidth == 1) { cond = strcmp (*(char **) text + (*offs)[p], newTextByte); @@ -899,7 +899,7 @@ struct __VsmxDecompileStack { int arrayFlag; VsmxDecompileStack *prev; - uint depth; + uint32_t depth; }; static inline void @@ -945,11 +945,11 @@ VsmxDecompileStackDestroy (VsmxDecompileStack ** stack) 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 @@ -965,7 +965,7 @@ VsmxDecompMarkStackPush (VsmxDecompMarkStack ** stack, 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; @@ -1002,7 +1002,7 @@ VsmxDecompMarkStackDestroy (VsmxDecompMarkStack ** stack) } static inline void -writeTabs (FILE * out, uint num) +writeTabs (FILE * out, uint32_t num) { while (num--) fputwc ('\t', out); @@ -1011,15 +1011,15 @@ writeTabs (FILE * out, uint num) 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", @@ -1088,7 +1088,7 @@ VsmxDecompile (VsmxMem * in, FILE * out) // 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, @@ -1204,7 +1204,7 @@ VsmxDecompile (VsmxMem * in, FILE * out) 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; @@ -1288,7 +1288,7 @@ VsmxDecompile (VsmxMem * in, FILE * out) 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); @@ -1321,7 +1321,7 @@ VsmxDecompile (VsmxMem * in, FILE * out) 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); @@ -1359,13 +1359,13 @@ VsmxDecompile (VsmxMem * in, FILE * out) { // 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 @@ -1495,7 +1495,7 @@ VsmxDecompile (VsmxMem * in, FILE * out) 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++) { diff --git a/vsmx.h b/vsmx.h index c164d41..72109db 100644 --- a/vsmx.h +++ b/vsmx.h @@ -7,18 +7,18 @@ typedef wchar_t wchar; #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; }); @@ -30,7 +30,7 @@ typedef struct { 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); diff --git a/xml.h b/xml.h index 8da3357..b72cd09 100644 --- a/xml.h +++ b/xml.h @@ -5,8 +5,8 @@ #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 @@ -26,11 +26,11 @@ extern RcoTableMap RCOXML_TABLE_REFTYPE; 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 diff --git a/xmlread.c b/xmlread.c index b40ebfc..9b5c41f 100644 --- a/xmlread.c +++ b/xmlread.c @@ -23,39 +23,39 @@ typedef struct { // 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 @@ -73,7 +73,7 @@ read_xml (char *fn) 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; @@ -125,7 +125,7 @@ read_xml (char *fn) 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)) @@ -227,7 +227,7 @@ read_xml (char *fn) 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) @@ -236,7 +236,7 @@ read_xml (char *fn) 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++) @@ -259,8 +259,8 @@ void 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; @@ -459,14 +459,14 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, 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, @@ -481,14 +481,14 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, 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++) { @@ -515,7 +515,7 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, // 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++) { @@ -530,7 +530,7 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, 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); @@ -566,7 +566,7 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, case RCO_TABLE_TEXT: if (entry->type == 1) { - Bool xmlInput = FALSE; + uint8_t xmlInput = FALSE; entry->extraLen = sizeof (rRCOTextEntry); entry->extra = malloc (entry->extraLen); @@ -578,10 +578,10 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, 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) { @@ -623,7 +623,7 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, 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++) { @@ -650,7 +650,7 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, // 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++) { @@ -670,12 +670,12 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, // 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)); @@ -713,17 +713,17 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, 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); @@ -742,7 +742,7 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, 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; // @@ -750,8 +750,8 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, * } 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, @@ -896,8 +896,8 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, } -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; @@ -906,7 +906,7 @@ rcoxml_text_to_int (char *s, const RcoTableMap map, uint * out) while (map[i][0]) { if (!strcasecmp (map[i], s)) { - *out = (uint) i; + *out = (uint32_t) i; return TRUE; } i++; @@ -917,12 +917,12 @@ rcoxml_text_to_int (char *s, const RcoTableMap map, uint * out) } // 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)) @@ -937,13 +937,13 @@ rcoxml_add_label (char **labels, uint * labelsLen, char *label, Bool eventQuirk) } // 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); @@ -955,7 +955,7 @@ rcoxml_add_label (char **labels, uint * labelsLen, char *label, Bool eventQuirk) *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); @@ -963,11 +963,11 @@ rcoxml_add_label (char **labels, uint * labelsLen, char *label, Bool eventQuirk) 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)) @@ -979,7 +979,7 @@ rcoxml_add_label_reordering (char *newLabels, uint * labelPos, char *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); @@ -994,10 +994,10 @@ label_reorder_qsort (const rRCOEntry ** a, const rRCOEntry ** b) } 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 = @@ -1026,25 +1026,25 @@ parse_obj_extra (xmlNodePtr node, rRCOEntry * entry) 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; @@ -1101,7 +1101,7 @@ parse_obj_extra (xmlNodePtr node, rRCOEntry * entry) 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 @@ -1115,7 +1115,7 @@ parse_obj_extra (xmlNodePtr node, rRCOEntry * entry) * 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); } @@ -1124,7 +1124,7 @@ parse_obj_extra (xmlNodePtr node, rRCOEntry * entry) extra += sizeof (rRCORef); i++; } else - extra += sizeof (uint32); + extra += sizeof (uint32_t); } } else { // TODO: handle unknown types @@ -1137,25 +1137,25 @@ 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, 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; @@ -1212,7 +1212,7 @@ parse_anim_extra (xmlNodePtr node, rRCOEntry * entry) 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 @@ -1226,7 +1226,7 @@ parse_anim_extra (xmlNodePtr node, rRCOEntry * entry) * 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); } @@ -1235,7 +1235,7 @@ parse_anim_extra (xmlNodePtr node, rRCOEntry * entry) extra += sizeof (rRCORef); i++; } else - extra += sizeof (uint32); + extra += sizeof (uint32_t); } } else { // TODO: handle unknown types @@ -1246,21 +1246,21 @@ parse_anim_extra (xmlNodePtr node, rRCOEntry * entry) * 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 = @@ -1282,15 +1282,15 @@ parse_anim_extra (xmlNodePtr node, rRCOEntry * entry) * 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]; @@ -1314,22 +1314,22 @@ rcoxml_get_unknown_attrib (xmlNodePtr node, uint num) } // 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 @@ -1401,7 +1401,7 @@ rcoxml_parse_ref (char *val, rRCORef * out) 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 && @@ -1409,9 +1409,9 @@ rcoxml_fix_refs (rRCOEntry * entry, rRCOFile * rco) || (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]; @@ -1424,13 +1424,13 @@ rcoxml_fix_refs (rRCOEntry * entry, rRCOFile * rco) extra += sizeof (rRCORef); i++; } else - extra += sizeof (uint32); + extra += sizeof (uint32_t); } /* * if(entry->id == RCO_TABLE_OBJ) { for(i=0, i2=0; * (int)itype]; 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); } } */ @@ -1446,7 +1446,7 @@ rcoxml_fix_refs (rRCOEntry * entry, rRCOFile * 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 || @@ -1512,10 +1512,10 @@ rcoxml_fix_ref (rRCORef * ref, rRCOFile * rco) } 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) { @@ -1530,7 +1530,7 @@ rcoxml_fix_ptrs (rRCOEntry *** sect, uint * sectCnt, rRCOFile * rco, strcpy (tmpText, text); - uint i; + uint32_t i; /* * for(i=0; itblMain), tmpTextPtr); @@ -1562,12 +1562,12 @@ rcoxml_fix_ptrs (rRCOEntry *** sect, uint * sectCnt, rRCOFile * rco, // 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 @@ -1587,7 +1587,7 @@ split_comma_list (char *s) char * strtrimr (char *in) { - uint len = strlen (in); + uint32_t len = strlen (in); while (len--) if (!isspace (in[len])) @@ -1602,7 +1602,7 @@ strtrimr (char *in) 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, '*'))) { @@ -1631,7 +1631,7 @@ expand_fname_to_fmt (char *in, char type) prevP = p; } - uint ppLen = strlen (prevP); + uint32_t ppLen = strlen (prevP); if (ppLen) { memcpy (newStrPtr, prevP, ppLen); @@ -1641,13 +1641,13 @@ expand_fname_to_fmt (char *in, char type) 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))) { @@ -1678,10 +1678,10 @@ parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry) 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) { @@ -1714,13 +1714,13 @@ parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry) 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 @@ -1732,7 +1732,7 @@ parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry) } } if (te->indexes[i].length > 2) { - uint contentLen = xmlStrlen (n), outBufLen = + uint32_t contentLen = xmlStrlen (n), outBufLen = te->indexes[i].length; textBuffer = @@ -1743,14 +1743,14 @@ parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry) 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), diff --git a/xmlwrite.c b/xmlwrite.c index e8a1e16..ab196bb 100644 --- a/xmlwrite.c +++ b/xmlwrite.c @@ -10,20 +10,20 @@ #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 ("\n", fp); @@ -75,15 +75,15 @@ write_xml (rRCOFile * rco, FILE * fp, char *textDir, Bool textXmlOut, } 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++; @@ -125,7 +125,7 @@ xmlwrite_entry (rRCOEntry * entry, uint depth, rRCOFile * rco, FILE * fp, 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); @@ -161,14 +161,14 @@ xmlwrite_entry (rRCOEntry * entry, uint depth, rRCOFile * rco, FILE * 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; iformat, 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++) { @@ -278,11 +278,11 @@ xmlwrite_entry (rRCOEntry * entry, uint depth, rRCOFile * rco, FILE * fp, } 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; } @@ -313,7 +313,7 @@ xmlwrite_entry (rRCOEntry * entry, uint depth, rRCOFile * rco, FILE * fp, } 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) { @@ -329,7 +329,7 @@ xmlwrite_entry_extra_object (uint16 type, uint8 * info, rRCOFile * rco, // 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); @@ -380,9 +380,9 @@ xmlwrite_entry_extra_object (uint16 type, uint8 * info, rRCOFile * rco, 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); @@ -393,7 +393,7 @@ xmlwrite_entry_extra_object (uint16 type, uint8 * info, rRCOFile * rco, } 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]; @@ -408,7 +408,7 @@ xmlwrite_entry_extra_anim (uint16 type, uint8 * info, rRCOFile * rco, FILE * fp) // 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); @@ -459,9 +459,9 @@ xmlwrite_entry_extra_anim (uint16 type, uint8 * info, rRCOFile * rco, FILE * 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); @@ -472,7 +472,7 @@ xmlwrite_entry_extra_anim (uint16 type, uint8 * 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) { int numEntries = RCO_ANIM_EXTRA_LEN[type]; int i; * * if(numEntries < 1) return; // TODO: handle unknown anim types? @@ -492,16 +492,16 @@ xmlwrite_entry_extra_anim (uint16 type, uint8 * info, rRCOFile * rco, FILE * fp) * 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: @@ -556,9 +556,9 @@ xml_fputref (rRCORef * ref, rRCOFile * rco, FILE * fp) } 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]) -- 2.39.5