From 3ea2414f52a1682ec3e6684d1ee12d85c9811b04 Mon Sep 17 00:00:00 2001 From: Youness Alaoui Date: Sun, 9 Jan 2011 09:28:08 -0500 Subject: [PATCH] Reindent all the files, no changes other than indentation and removal of trailing whitespaces --- general.c | 14 ++-- general.h | 9 +-- globdefs.c | 2 +- main.c | 52 ++++++------- rcodump.c | 82 ++++++++++---------- rcodump.h | 3 +- rcofile.h | 97 ++++++++++++++++-------- rcomain.c | 13 ++-- rcomain.h | 81 +++++++++++--------- rcoreader.c | 64 +++++++++------- rcowriter.c | 103 +++++++++++++------------ rlzpack.c | 203 ++++++++++++++++++++++++++----------------------- vaghandler.c | 75 +++++++++--------- vaghandler.h | 6 +- vsmx.c | 47 ++++++------ xml.h | 4 +- xmlread.c | 209 +++++++++++++++++++++++++++------------------------ xmlwrite.c | 62 +++++++-------- 18 files changed, 612 insertions(+), 514 deletions(-) diff --git a/general.c b/general.c index 0b7de9a..f01f183 100644 --- a/general.c +++ b/general.c @@ -18,8 +18,8 @@ #include "7z/7z.h" uint32_t -zlib_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int level, - int strat) +zlib_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, + int level, int strat) { if (strat == Z_USE_7Z) { // compress with 7z @@ -156,11 +156,13 @@ zlib_unpacked_size (void *src, uint32_t srcLen) } uint32_t -rlz_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int mode) +rlz_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, + int mode) { if (mode == -1) { // theme creator compatible mode - // we'll be just as bad as the theme creator and run _4_ compression passes + // we'll be just as bad as the theme creator and run _4_ compression passes + // // >_> int size5, size6, size7; @@ -175,7 +177,7 @@ rlz_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int mode if (size7 != -1 && (size7 < size6 || size6 != -1) && (size7 < size5 || size5 != -1)) return size7; // okay, we're _slightly_ more optimised than - // the theme creator :P + // the theme creator :P if (size6 != -1 && (size6 < size5 || size5 != -1)) return rlzcompress (dest, srcLen, src, 6); if (size5 != -1) @@ -243,7 +245,7 @@ uint8_t is_prime (uint32_t in) { if (in < 12) { // need this buffer as "lim" (below) may - // underflow + // underflow return (in <= 3 || in == 5 || in == 7 || in == 11); } // filter out half the results by checking if the number is even diff --git a/general.h b/general.h index 943cc37..07cb767 100644 --- a/general.h +++ b/general.h @@ -19,7 +19,6 @@ #define APPXMLVER 1.10f #define APPVER 1.11f - #ifndef TRUE #define TRUE (uint8_t)1 #endif @@ -56,19 +55,19 @@ extern uint8_t quietMode; // #define ALIGN_TO_4(n) (((n) + 3) >>2 <<2) // problem: upper 2 bits gets // wiped too - #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 -uint32_t zlib_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, int level, - int strat); +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); 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); +uint32_t rlz_compress (void *src, uint32_t srcLen, void *dest, uint32_t destLen, + int mode); uint8_t file_exists (char *fn); uint32_t filesize (const char *fn); diff --git a/globdefs.c b/globdefs.c index 7f2e499..a4dec8a 100644 --- a/globdefs.c +++ b/globdefs.c @@ -44,7 +44,7 @@ RcoTableMap RCOXML_TABLE_IMG_FMT = NULL; RcoTableMap RCOXML_TABLE_MODEL_FMT = NULL; RcoTableMap RCOXML_TABLE_SOUND_FMT = NULL; -// const RcoTableMap RCOXML_TABLE_REFTYPE = {"event", "text"}; // TODO: +// const RcoTableMap RCOXML_TABLE_REFTYPE = {"event", "text"}; // TODO: RcoTagMap RCOXML_TABLE_TAGS = NULL; diff --git a/main.c b/main.c index bf9db53..15f2f0e 100644 --- a/main.c +++ b/main.c @@ -260,19 +260,19 @@ main_help () * replacing sound resources.\n" "\n" "\nOptions:\n" " --lang * Language of text to replace. [English]\n" " See '%s help extract' for * valid values.\n" " --channel Replace sound channel . [1]\n" " - * --format Format of imported resource. Only applies to image,\n" " - * sound and model resources. You can use a format ID, or\n" " the + * --format Format of imported resource. Only applies to image,\n" " + * * sound and model resources. You can use a format ID, or\n" " the * following:\n"); // TODO: printf( " --pack How to compress this * resource.\n" #ifdef DISABLE_RLZ " Valid values are 'none' and 'zlib'.\n" * #else " Valid values are 'none', 'zlib' and 'rlz'.\n" #endif " Only * applies to images and models. By default, will use\n" " 'zlib' unless * format is PNG/JPG/TIF/GIF where 'none' will\n" " be used.\n"); * PRINT_PACK_OPTS; return 0; } */ - /* + /* * else if(!strcasecmp(app_argv[2], "list")) { printf("Syntax: %s list - * [options]\n", app_argv[0]); printf(" List resources in an easy + * [options]\n", app_argv[0]); printf(" List resources in an easy * to parse format.\n"); printf("\n"); printf("\nOptions:\n"); printf(" - * --type Only list resources of a certain type.\n"); printf(" Types + * --type Only list resources of a certain type.\n"); printf(" Types * can be 'image', 'sound', 'model', \n"); printf(" --no-recurse Don't * write UCS BOM.\n"); printf(" The following option only applies for * extracting sound resources.\n"); printf(" --channel Extract sound @@ -348,7 +348,7 @@ main_help () printf (" --ini-dir Specify directory containing Rcomage INI files.\n"); - /* + /* * printf("\n"); printf("\nGeneral options:\n"); printf("\n"); printf(" * --pack \n"); */ @@ -411,15 +411,15 @@ main_dump (void) else MAIN_INV_CMD_SYNTAX} if (!sRcoFile || !sXmlFile) - MAIN_INV_CMD_SYNTAX if (gimconvOpts.ext && strlen (gimconvOpts.ext) > 5) { - gimconvOpts.ext[5] = '\0'; // prevent buffer overflow - if (gimconvOpts.cmd && strlen (gimconvOpts.cmd) > 255) { - gimconvOpts.cmd[255] = '\0'; // prevent buffer overflow - } - if (gimconvOpts.extFlags && strlen (gimconvOpts.extFlags) > 512) { - gimconvOpts.extFlags[512] = '\0'; // prevent buffer overflow - } + MAIN_INV_CMD_SYNTAX if (gimconvOpts.ext && strlen (gimconvOpts.ext) > 5) { + gimconvOpts.ext[5] = '\0'; // prevent buffer overflow + if (gimconvOpts.cmd && strlen (gimconvOpts.cmd) > 255) { + gimconvOpts.cmd[255] = '\0'; // prevent buffer overflow } + if (gimconvOpts.extFlags && strlen (gimconvOpts.extFlags) > 512) { + gimconvOpts.extFlags[512] = '\0'; // prevent buffer overflow + } + } rRCOFile *rco = read_rco (sRcoFile); @@ -575,9 +575,7 @@ main_dump (void) if (entry) { /* if(entry->id == RCO_TABLE_SOUND && entry->type == 1) { // handle - * sound channel stuff - * - * } */ + * sound channel stuff } */ if (stTextLang) warning ("Resource '%s' is not text.", sResLabel); if (!dump_resource (sOutFile, entry, dump_output_data, NULL)) { @@ -798,11 +796,12 @@ main_dump (void) if (!sNoConvVag) { rco_map_func (rco, NULL, NULL, compile_vagconv_map); } else - rco_map_func (rco, NULL, NULL, compile_wavcheck_map); // verify there - // are no - // orphaned - // .wav sound - // references + rco_map_func (rco, NULL, NULL, compile_wavcheck_map); // verify there + // + // are no + // orphaned + // .wav sound + // references if (!sNoConvVsmx) { rco_map_func (rco, NULL, NULL, compile_vsmxconv_map); } @@ -873,9 +872,9 @@ main_dump (void) fread (((char **) buf)[channels] + len[channels], 1, READ_BUFFER, fp); } - /* + /* * fseek(fp, 0, SEEK_END); len[channels] = ftell(fp); rewind(fp); - * + * * buf[channels] = malloc(len[channels]); fileread(fp, * buf[channels], len[channels]); */ fclose (fp); @@ -888,7 +887,8 @@ main_dump (void) warning ("Unable to open file %s", app_argv[i]); } - uint8_t 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--) @@ -1117,7 +1117,7 @@ main_dump (void) if (warnUnk && j == num) { error ("Unknown option '%s'.", app_argv[i]); exit (RETERR_SYNTAX); - /* warning("Unknown option '%s'.", argv[i]); argv[i][0] = '\0'; + /* warning("Unknown option '%s'.", argv[i]); argv[i][0] = '\0'; * // don't warn them again */ } } diff --git a/rcodump.c b/rcodump.c index df1962f..31eb021 100644 --- a/rcodump.c +++ b/rcodump.c @@ -319,36 +319,37 @@ dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, // *new* fix entry here as well strcpy (entry->srcFile, fullOutName); - entry->srcLenUnpacked = filesize (fullOutName); // get around issues of - // conversions changing - // filesize :P (dirty, - // but works!) + entry->srcLenUnpacked = filesize (fullOutName); // get around issues of + // + // conversions changing + // filesize :P (dirty, + // but works!) } - /* + /* * for(j=0; jid == RCO_TABLE_SOUND) { // * do something dirty - hack the srcFile here... outName[len+1] = '\0'; * strcpy(soundSetSrc, fullOutName); strcpy(soundSetSrc + * strlen(soundSetSrc), "ch*.vag"); - * + * * sprintf(outName + len +1, "ch%d.", j); len = strlen(outName) -1; } * strcpy(outName + len +1, ext); - * + * * // trick dump_resource() into doing what we want it to by fiddling with * 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 += * ((rRCOSoundEntry*)entry->extra)->channelData[j*2+1]; } - * + * * if((fp = fopen(fullOutName, "wb"))) { if(!dump_resource(fp, entry)) * warning("Unable to dump resource '%s'.", labels + entry->labelOffset); * fclose(fp); } else warning("Unable to write to file '%s'.", * fullOutName); - * + * * entry->srcAddr = origAddr; entry->srcLen = origLen; * entry->srcLenUnpacked = origLenUnpacked; - * + * * // *new* fix entry here as well if(entry->id != RCO_TABLE_SOUND) * strcpy(entry->srcFile, fullOutName); } */ entry->srcAddr = 0; @@ -511,19 +512,19 @@ dump_text_resources (char *labels, rRCOEntry * parent, uint8_t writeHeader, char *bufOut = buf; uint32_t outBufLen = 4096; - /* { // feed in the BOM (is it really necessary though?) uint32_t number; - * char* unicodePtr; if(textEntry->format == RCO_TEXT_FMT_UTF32) { - * 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_t bom = UTF8_BOM; number = 3; unicodePtr = - * (char*)&bom; iconv(ic, (const char**)(&unicodePtr), - * (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 + /* { // feed in the BOM (is it really necessary though?) uint32_t + * number; char* unicodePtr; if(textEntry->format == + * RCO_TEXT_FMT_UTF32) { 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_t bom = UTF8_BOM; + * * number = 3; unicodePtr = (char*)&bom; iconv(ic, (const * char**)(&unicodePtr), (size_t*)(&number), &bufOut, - * (size_t*)(&outBufLen)); } } */ + * (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)); } } */ uint32_t nullsStripped = 0; while (dataLen) { @@ -546,7 +547,7 @@ dump_text_resources (char *labels, rRCOEntry * parent, uint8_t writeHeader, } outBufLen = 4096; bufOut = buf; - /* + /* * filewrite(fp, buf, bufOut-buf); outBufLen = 4096; bufOut = buf; */ } if (nullsStripped) @@ -701,23 +702,24 @@ exec_gimconv (char *cmd, char *src, char *dest, char *extFlags) } // gimconv is screwy and sometimes prepends a '/' to our destination file // so we do our feeble attempt to determine if it is a relative path - if (dest[0] == '\\' || dest[0] == '/' || dest[0] == '.' || dest[1] == ':') // should - // handle - // "\file", - // "\\network\blah" - // and - // "C:\file" - // notations; - // gimconv - // seems - // to - // also - // escape - // if - // first - // char - // == - // '.' + if (dest[0] == '\\' || dest[0] == '/' || dest[0] == '.' || dest[1] == ':') // should + // + // handle + // "\file", + // "\\network\blah" + // and + // "C:\file" + // notations; + // gimconv + // seems + // to + // also + // escape + // if + // first + // char + // == + // '.' sprintf (gimconvCmd + strlen (gimconvCmd), " \"%s\" -o \"%s\"", src, dest); else sprintf (gimconvCmd + strlen (gimconvCmd), " \"%s\" -o \"./%s\"", src, diff --git a/rcodump.h b/rcodump.h index d846c48..e387ee9 100644 --- a/rcodump.h +++ b/rcodump.h @@ -25,7 +25,8 @@ void dump_resources (char *labels, rRCOEntry * parent, const RcoTableMap extMap, 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); +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 9408e37..8dd2d07 100644 --- a/rcofile.h +++ b/rcofile.h @@ -26,7 +26,7 @@ #define RCO_SIGNATURE 0x46525000 // .PRF (PSP Resource File?) PACK_STRUCT (PRFHeader, { - uint32_t signature; // RCO_SIGNATURE + uint32_t signature; // RCO_SIGNATURE uint32_t version; // 0x70 - UMD RCOs (video?), FW1.00 // 0x71 - UMD RCOs (audio?), FW1.50, FW2.50 @@ -35,9 +35,10 @@ PACK_STRUCT (PRFHeader, { // 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_t null; - uint32_t compression; // upper nibble = compression, lower nibble: - // 0=flash0 RCOs, 1=UMD RCOs???? - /* + 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 @@ -46,19 +47,21 @@ PACK_STRUCT (PRFHeader, { 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 pImgTable; // type 4 + uint32_t pUnknown; // always 0xFFFFFFFF uint32_t pFontTable; // type 7 - uint32_t pObjTable; // type 8 + uint32_t pObjTable; // type 8 uint32_t pAnimTable; // type 9 // text stuff - uint32_t pTextData; // NOTE: this may == pLabelData if lTextData == - // 0 + uint32_t pTextData; // NOTE: this may == pLabelData if lTextData == + // + // 0 uint32_t lTextData; uint32_t pLabelData; uint32_t lLabelData; uint32_t pEventData; uint32_t lEventData; // pointer data - uint32_t pTextPtrs; uint32_t lTextPtrs; uint32_t pImgPtrs; uint32_t lImgPtrs; + 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; @@ -80,18 +83,31 @@ PACK_STRUCT (RCOEntry, { 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_t entrySize; // main tables (main/img etc) uses 0x28 here, - // or is this the length of current entry (not - // including subentries)? + uint32_t eHeadSize; // = + // sizeof(RCOEntry) + // = + // 0x28 + // [ + // only + // used + // for + // entries with extra info (ie not "main" + // entries) ] + uint32_t entrySize; // main tables (main/img etc) uses 0x28 here, + // or is this the length of current entry (not + // including subentries)? // 0x10 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_t prevEntryOffset; // this + // is + // usually + // 0x0 + // however + // (does + // make + // writing RCOs easier though :P I guess Sony's + // tools do something similar...) uint32_t parentTblOffset; // offset of this entry from parent table // 0x20 uint32_t blanks[2]; @@ -147,31 +163,42 @@ PACK_STRUCT (RCOTextIndex, { #define RCO_MODEL_GMO 0x0 PACK_STRUCT (RCOImgModelEntry, { uint16_t format; - uint16_t compression; // RCO_DATA_COMPRESSION_* constants + 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 + 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_t format; - uint16_t compression; // RCO_DATA_COMPRESSION_* constants + 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_t something; // PS3 RCOs + // seem to have + // this extra + // element - + // probably something to do with + // planes/frames?? usually 0x1 uint32_t sizeUnpacked; // this value doesn't exist if entry isn't - // compressed + // compressed }); #define RCO_SOUND_VAG 0x1 PACK_STRUCT (RCOSoundEntry, { uint16_t format; // 0x01 = VAG - uint16_t channels; // 1 or 2 channels + uint16_t channels; // 1 or 2 channels uint32_t sizeTotal; uint32_t offset; // now pairs of size/offset for each channel @@ -239,16 +266,22 @@ PACK_STRUCT (RCOReference, { PACK_STRUCT (HeaderComprInfo, { uint32_t lenPacked; uint32_t lenUnpacked; - uint32_t lenLongestText; // length of the longest language's text data - // (unpacked) + uint32_t lenLongestText; // length + // of + // the + // longest + // language's + // text + // data + // (unpacked) }); PACK_STRUCT (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 + // packedLen); is 0 for last text entry + // regardless of what actually comes after uint32_t packedLen; uint32_t unpackedLen; }); diff --git a/rcomain.c b/rcomain.c index f4d0817..b23a6f8 100644 --- a/rcomain.c +++ b/rcomain.c @@ -48,11 +48,11 @@ get_label_from_offset (char *labels, uint32_t labelOffset) } } -/* +/* * rRCOEntry* rco_add_entry(rRCOEntry* parent, rRCOEntry* newEntry, int pos) { * rRCOEntry* dest; if(pos != -1 && pos > (int)(parent->numSubentries)) return * NULL; - * + * * if(!parent->numSubentries) { parent->subentries = * (rRCOEntry*)malloc(sizeof(rRCOEntry)); dest = parent->subentries; } else { * parent->subentries = (rRCOEntry*)realloc(parent->subentries, @@ -62,9 +62,9 @@ get_label_from_offset (char *labels, uint32_t labelOffset) * parent->numSubentries - pos; //rRCOEntry* tmpBuffer = (rRCOEntry*)malloc() * memcpy(&(parent->subentries[pos+1]), &(parent->subentries[pos]), * numEntriesToMove * sizeof(rRCOEntry)); } } - * + * * parent->numSubentries++; memcpy(dest, newEntry, sizeof(rRCOEntry)); - * + * * return dest; } */ // parses an RCO (give it the main entry) to fix any resource which is @@ -139,7 +139,8 @@ read_resource (rRCOEntry * entry, uint32_t * outLen) } if (entry->srcCompression == RCO_DATA_COMPRESSION_RCO) { - // special case where stuff is embedded in RCO - this should only be used + // special case where stuff is embedded in RCO - this should only be used + // // with VSMX, so we'll take a short cut here, but: // TODO: do some extra checks to enforce the above @@ -484,7 +485,7 @@ es_extraObjAnim (uint8_t isObj, int type, void *data, uint8_t isPS3) #define ENDIAN_SWAP_HALF32(x) (((x) & 0xFF) << 8 | ((x) & 0xFF00) >> 8 | ((x) & 0xFF0000) << 8 | ((x) & 0xFF000000) >> 8) - /* + /* * if(!isObj && RCO_ANIM_EXTRA_REFS[type]) { uData[0] = * ENDIAN_SWAP_HALF32(uData[0]); uData[1] = ENDIAN_SWAP(uData[1]); i = 2; } */ diff --git a/rcomain.h b/rcomain.h index 74a72a9..3a5f29c 100644 --- a/rcomain.h +++ b/rcomain.h @@ -31,15 +31,15 @@ typedef struct { typedef struct __rRCOEntry { uint8_t type; // main table uses 0x01; may be used as a - // current entry depth value + // current entry depth value uint8_t id; // char* label; uint32_t labelOffset; - 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) + 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) // this value is also used to store the line number of the node when reading // an XML @@ -59,12 +59,12 @@ typedef struct __rRCOEntry { uint32_t srcAddr; uint32_t srcLen; uint32_t srcLenUnpacked; - uint32_t srcCompression; // use RCO_DATA_COMPRESSION_* constants in - // rcofile.h + 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 - // check if srcFile contains a '*', then use - // this + // used for sound and text entries; need to + // check if srcFile contains a '*', then use + // this } rRCOEntry; typedef struct { @@ -74,7 +74,8 @@ typedef struct { RCOTextIndex *indexes; } rRCOTextEntry; -/* packed_struct { char* label; uint32_t length; uint32_t offset; } rRCOTextIndex; */ +/* packed_struct { char* label; uint32_t length; uint32_t offset; } + * rRCOTextIndex; */ typedef struct { rRCOEntry *textEntry; RCOTextIndex *index; @@ -89,7 +90,7 @@ typedef struct __rRCOFile { char *events; uint32_t eventsLen; - /* + /* * // 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 @@ -107,7 +108,7 @@ typedef struct __rRCOFile { // additional info about the source (mainly used for displaying info about // the RCO) - uint32_t verId; // offset 0x04 in file + uint32_t verId; // offset 0x04 in file uint32_t umdFlag; uint32_t headerCompression; uint8_t eSwap; @@ -117,27 +118,28 @@ typedef struct __rRCOFile { typedef struct { uint32_t type; - void *ptr; // will usu be rRCOEntry*, but may be char* for - // events; NULL if type is nothing + void *ptr; // will usu be rRCOEntry*, but may be char* for + // + // events; NULL if type is nothing uint32_t rawPtr; // raw value from source - means nothing if - // type is known + // type is known } rRCORef; typedef struct { uint32_t format; uint32_t compression; uint32_t unkCompr; // unknown - usually 0, some PS3 rcos have 1 - // here + // here } rRCOImgModelEntry; typedef struct { uint16_t format; // 0x01 = VAG uint16_t channels; // 1 or 2 channels - uint32_t *channelData; // size/offset pairs + uint32_t *channelData; // size/offset pairs } rRCOSoundEntry; typedef struct { - uint32_t format; // 1 + uint32_t format; // 1 uint32_t compression; // 0 uint32_t unknown; uint32_t unknown2; @@ -234,25 +236,32 @@ PACK_STRUCT (RCOObjPos, { float colR; float colG; float colB; - float colA; // RGBA colour weights + float colA; // RGBA + + // colour + // weights float dimW; float dimH; float unknown; float sclX; - float sclY; // scale values + float sclY; // scale + + // values float elemScale; - 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 - // somehow. - rRCORef loadAction; // the event/anim executed on image load (note, - // load, not display) or describes when image - // is loaded? (eg onShadowInit) + 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 + // somehow. + rRCORef loadAction; // the event/anim executed on image load (note, + // + // load, not display) or describes when image + // is loaded? (eg onShadowInit) }); -/* +/* * 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 @@ -260,7 +269,7 @@ PACK_STRUCT (RCOObjPos, { * 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 + * 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_t unknown; // appears to be 0xFFFFFFFF @@ -311,13 +320,13 @@ PACK_STRUCT (RCOObjPos, { * 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_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; // + * 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_t unknown; float unknown2; rRCORef text1; rRCORef text2; rRCORef ref1; - * rRCORef ref2; rRCORef event1; rRCORef event2; rRCORef ref3; rRCORef ref4; rRCORef + * 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 * ref2; rRCORef event; rRCORef ref3; }); // 0x17 PACK_STRUCT(RCOObjSIItem, { @@ -328,10 +337,10 @@ PACK_STRUCT (RCOObjPos, { * rRCORef ref1; // [object/event] rRCORef ref2; // [object/event] rRCORef ref3; // * [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_t unknown; float x; * float y; float unknown2; }); PACK_STRUCT(RCOAnimSColour, { rRCORef obj; float - * time; uint32_t 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_t unknown; // dunno whether float or int * (probably int) uint32_t unknown2; // dunno whether float or int (probably int) diff --git a/rcoreader.c b/rcoreader.c index d3a2482..7ee9504 100644 --- a/rcoreader.c +++ b/rcoreader.c @@ -22,7 +22,7 @@ typedef struct { char *fName; uint32_t fSize; - uint32_t fSizeExpanded; // file size with decompressed header + uint32_t fSizeExpanded; // file size with decompressed header void *tables; // decompressed tables uint32_t tablesSize; @@ -107,7 +107,7 @@ read_rco (char *fn) } rco->umdFlag = header.compression & 0xF; // actually, I'm usure about - // this, but meh + // this, but meh rco->headerCompression = header.compression >> 4; rco->verId = header.version; @@ -247,8 +247,8 @@ read_rco (char *fn) return NULL; default: // this won't actually ever be executed due to - // the new compression checking code above... - // :/ + // the new compression checking code above... + // :/ error ("[header] Unknown compression method specified (0x%x) - can't continue.", rco->headerCompression); @@ -258,7 +258,7 @@ read_rco (char *fn) // decompress text data if (header.pTextData != RCO_NULL_PTR && header.lTextData) { fseek (rcoH.fp, header.pTextData, SEEK_SET); // TODO: check offset - // first! + // first! TextComprInfo tci; info ("TextData Compression info:"); @@ -301,14 +301,15 @@ read_rco (char *fn) } free (readBuf); - rcoH.fSizeExpanded += ALIGN_TO_4 (tci.unpackedLen) - ALIGN_TO_4 (tci.packedLen); // TODO: - // need - // to - // check - // if - // this - // is - // correct + rcoH.fSizeExpanded += ALIGN_TO_4 (tci.unpackedLen) - ALIGN_TO_4 (tci.packedLen); // TODO: + // + // need + // to + // check + // if + // this + // is + // correct if (!tci.nextOffset) break; @@ -382,7 +383,7 @@ read_rco (char *fn) rco_fread(&rcoH, dp, hl); \ } \ } - /* + /* * READ_RCO_READ_PTR_SEGMENT(header.pTextPtrs, header.lTextPtrs, * rcoH.ptrsText, rcoH.numTextPtrs, "text"); * READ_RCO_READ_PTR_SEGMENT(header.pImgPtrs, header.lImgPtrs, @@ -588,7 +589,7 @@ read_rco (char *fn) warning ("[header] Model resource pointer/length is invalid."); } - /* + /* * rco->pDataText = header.pTextData; rco->lDataText = header.lTextData; * if(!rco->lDataText) rco->pDataText = 0; rco->pDataImg = header.pImgData; * rco->lDataImg = header.lImgData; if(!rco->lDataImg) rco->pDataImg = 0; @@ -596,7 +597,7 @@ read_rco (char *fn) * if(!rco->lDataSound) rco->pDataSound = 0; rco->pDataModel = * header.pModelData; rco->lDataModel = header.lModelData; * if(!rco->lDataModel) rco->pDataModel = 0; - * + * * rco->attachSource = (char*)malloc(strlen(fn) +1); * strcpy(rco->attachSource, fn); */ } @@ -804,7 +805,8 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, compression &= 0xFF; if (compression == RCO_DATA_COMPRESSION_NONE) { // assume that this doesn't include the packed length value - // ...but we'll still at least _try_ to see if this isn't a short + // ...but we'll still at least _try_ to see if this isn't a short + // // entry (not guaranteed to succeed, especially for the last // image entry) if (!re.nextEntryOffset || @@ -842,10 +844,10 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, return; } - /* + /* * // dirty hack for reading PS3 stuff if(rco->ps3 && extraSize == * rimeSize) extraSize -= sizeof(uint32_t); - * + * * 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; } @@ -1101,18 +1103,22 @@ read_entry (rRCOFile_readhelper * rcoH, rRCOFile * rco, rRCOEntry * data, // our ugly hack to get around borked update_plugin.rco when decompressed // with Resurssiklunssi - // the issue is that the image isn't compressed by default, so uses a short + // the issue is that the image isn't compressed by default, so uses a short + // // image entry (ie, doesn't include decompressed size), however - // Resurssiklunssi will compress it but won't add in this decompressed size + // Resurssiklunssi will compress it but won't add in this decompressed size + // // since there is no room for it // rcomage expects a decompressed size so will assume it exists (no way to // tell if it's not there) but this will cause an alignment error for the - // parent. The only way to detect this is, thus, trap this alignment error + // parent. The only way to detect this is, thus, trap this alignment error + // // and check the child entry // still, we are left without a decompressed size, thus we have to figure // out something for this - // we'll do this by seeing if the misalignment is -4 and the previous entry + // we'll do this by seeing if the misalignment is -4 and the previous entry + // // is a compressed image/model; if there are child entries, we'll check // this instead of the previous entry // obviously this isn't guaranteed to work in 100% of cases, but will get @@ -1160,7 +1166,8 @@ fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray, { uint32_t i, i2; - // only fix refs if type is known, and not the main object(0x800)/anim(0x900) + // 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) { @@ -1168,7 +1175,8 @@ fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray, uint32_t destSize = lenArray[entry->type] * sizeof (uint32_t); if (isObj) { - for (i = 0, i2 = 0; i < (uint32_t) 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_t) * 2; // size of ref source destSize += sizeof (rRCORef); @@ -1177,7 +1185,8 @@ fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray, } else { /* 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 < (uint32_t) 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_t) * 2; // size of ref source destSize += sizeof (rRCORef); @@ -1244,7 +1253,8 @@ fix_refs (rRCOFile * rco, rRCOEntry * entry, const int *lenArray, i++; destPtr += sizeof (rRCORef); } else { - *(uint32_t *) destPtr = *(uint32_t *) ((uint8_t *) entry->extra + i * 4); + *(uint32_t *) destPtr = + *(uint32_t *) ((uint8_t *) entry->extra + i * 4); destPtr += sizeof (uint32_t); } } diff --git a/rcowriter.c b/rcowriter.c index 73c7cd2..9f409ce 100644 --- a/rcowriter.c +++ b/rcowriter.c @@ -30,9 +30,10 @@ typedef struct { // memory compression thing void *tables; uint32_t tablesSize; - uint32_t tablesBuffered; // internal value used for buffering, following - // define is the amount to increase the buffer - // by when necessary + 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 uint32_t memPos; uint32_t memOffset; // should always be 0xA4 @@ -45,10 +46,11 @@ 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); -uint32_t rco_write_resource (FILE * dest, rRCOEntry * entry, uint32_t destCompression, - writerco_options * opts, rRCOFile * rco); -uint32_t rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, - uint32_t destCompression, writerco_options * opts, uint32_t lang, uint8_t isLast); +uint32_t rco_write_resource (FILE * dest, rRCOEntry * entry, + uint32_t destCompression, writerco_options * opts, rRCOFile * rco); +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, uint8_t isObj); @@ -91,8 +93,8 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) (opts.packHeader == RCO_DATA_COMPRESSION_RLZ ? 0x95 : opts.packHeader == RCO_DATA_COMPRESSION_ZLIB ? 0x90 : 0x71); if (rco->verId) { // we won't actually use specified value, - // rather, we'll require using the minimum - // version from above + // rather, we'll require using the minimum + // version from above if (rco->verId > header.version) header.version = rco->verId; } @@ -248,7 +250,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) { // write hashtable data - /* { // special case for text hashes if(rco->numPtrText) { header.pTextPtrs + /* { // special case for text hashes if(rco->numPtrText) { header.pTextPtrs * = 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) + @@ -295,7 +297,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) header.lAnimPtrs = 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_t)); \ @@ -313,7 +315,7 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) } { // write label/event data (and text if - // applicable) + // applicable) // write text (note, old behaviour - newer RCOs have text written in a // different location) @@ -336,12 +338,12 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) if (rco->eventsLen) rco_fwrite (&rcoH, rco->events, rco->eventsLen); else if (rco->tblObj || rco->tblAnim) { // weird case: if there's - // object entries, there will - // be 4 bytes for events; I'll - // assume this covers anim as - // well (although there isn't - // an RCO with anim that - // doesn't have objects) + // object entries, there will + // be 4 bytes for events; I'll + // assume this covers anim as + // well (although there isn't + // an RCO with anim that + // doesn't have objects) uint32_t zero = 0; rco_fwrite (&rcoH, &zero, sizeof (zero)); @@ -422,19 +424,15 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) * uint32_t packedSize = rco_write_resource(&rcoH, * &(rco->tblImage->subentries[i]), RCO_DATA_COMPRESSION_NONE); // TOxDO: * change this // TOxDO: update packed size value uint32_t curFpos = - * rcowrite_ftell(rcoH.fp); - * - * totalPackedLen += (packedSize % 4 ? (packedSize/4)*4+4 : packedSize); } - * header.lImgData = totalPackedLen; } - * + * rcowrite_ftell(rcoH.fp); totalPackedLen += (packedSize % 4 ? + * (packedSize/4)*4+4 : packedSize); } header.lImgData = totalPackedLen; } * totalPackedLen = 0; if(rco->tblSound) { header.pSoundData = * rcowrite_ftell(&rcoH); header.lSoundData = rcoH.sizeSound; for(i=0; * itblSound->numSubentries; i++) { totalPackedLen += * rco_write_resource(&rcoH, &(rco->tblSound->subentries[i]), * RCO_DATA_COMPRESSION_NONE); if(totalPackedLen %4) totalPackedLen += - * 4-(totalPackedLen%4); } header.lSoundData = totalPackedLen; } - * - * // TOxDO: write model resources } */ + * 4-(totalPackedLen%4); } header.lSoundData = totalPackedLen; } // TOxDO: + * write model resources } */ if ((rco->tblImage && rco->tblImage->numSubentries) || (rco->tblSound && rco->tblSound->numSubentries) @@ -499,12 +497,13 @@ write_rco (rRCOFile * rco, char *fn, writerco_options opts) return TRUE; } -// returns next entry offset (like the length, but the last entry returns zero) +// 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 uint32_t -write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint32_t parentOffset, - uint32_t prevOffset, uint8_t isLastSubentry) +write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, + uint32_t parentOffset, uint32_t prevOffset, uint8_t isLastSubentry) { uint32_t fPos = rcowrite_ftell (rcoH); @@ -610,17 +609,19 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint32_t parentOffs rti.offset = RCO_NULL_PTR; else if (rti.length) { if (rcoH->tables) // compressing - we need to make the offset - // relative to the section of text data + // relative to the section of text data rti.offset = rcoH->sizeText - entryTextOffset; else rti.offset = rcoH->sizeText; - } else // TODO: experimental (it seems that Sony likes - // sticking in a weird pointer for a blank text - // entry) + } else // TODO: experimental (it seems that Sony likes + // + // sticking in a weird pointer for a blank text + // entry) rti.offset = entryTextOffset - 1; - rcoH->sizeText += rti.length; // doesn't have trailing null, so no +1 - // needed + rcoH->sizeText += rti.length; // doesn't have trailing null, so no +1 + // + // needed // align to 4 byte boundary rcoH->sizeText = ALIGN_TO_4 (rcoH->sizeText); @@ -709,7 +710,8 @@ write_entry (rRCOFile_writehelper * rcoH, rRCOEntry * entry, uint32_t parentOffs uint32_t stuffToWrite[] = { 0, RCO_NULL_PTR }; uint32_t i; - // actually, the following is unnecessary, but we'll keep it here for + // actually, the following is unnecessary, but we'll keep it here for + // // reference sake if (entry->rco->eSwap) { stuffToWrite[0] = ENDIAN_SWAP (stuffToWrite[0]); @@ -840,7 +842,8 @@ rcowrite_fseek (rRCOFile_writehelper * rcoH, uint32_t pos) } // returns the length of the packed data -// TBH, I really can't be stuffed writing a buffered copy/compress/decompressor +// 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) uint32_t rco_write_resource (FILE * dest, rRCOEntry * entry, uint32_t destCompression, @@ -905,27 +908,27 @@ rco_write_resource (FILE * dest, rRCOEntry * entry, uint32_t destCompression, filewrite (dest, bufferOut, packedSize); free (bufferOut); - /* + /* * 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) { uint32_t readAmt = (len < 65536 ? len : * 65536); if(!fileread(src, &buffer, readAmt)) { fclose(src); return FALSE; * } - * + * * if(destCompression == RCO_DATA_COMPRESSION_NONE) filewrite(dest, &buffer, * readAmt); else if(destCompression == RCO_DATA_COMPRESSION_ZLIB) { - * + * * } - * + * * len -= readAmt; } - * + * * // TOxDO: also don't forget to check lenUnpacked - * + * * fclose(src); - * + * * if(destStream == RCO_DATA_COMPRESSION_ZLIB) deflateEnd(&out); */ // 4byte alignment @@ -940,7 +943,8 @@ rco_write_resource (FILE * dest, rRCOEntry * entry, uint32_t destCompression, uint32_t rco_write_text_resource (rRCOFile_writehelper * rcoH, rRCOEntry * entry, - uint32_t destCompression, writerco_options * opts, uint32_t lang, uint8_t isLast) + uint32_t destCompression, writerco_options * opts, uint32_t lang, + uint8_t isLast) { uint32_t len = 0; @@ -1142,7 +1146,8 @@ write_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry, if (entry->id == RCO_TABLE_OBJ) num = count_all_subentries (entry); // if(!rco->ps3) - // interestingly, it seems that some PS3 RCOs do not round to an upper prime, + // interestingly, it seems that some PS3 RCOs do not round to an upper prime, + // // but most do num = find_larger_prime (num); @@ -1200,8 +1205,8 @@ write_text_hash_table (rRCOFile_writehelper * rcoH, rRCOEntry * entry, } void -do_hashing (rRCOEntry * entry, rRCOFile * rco, uint8_t recurse, uint32_t * hashTable, - uint32_t hashTableSize) +do_hashing (rRCOEntry * entry, rRCOFile * rco, uint8_t recurse, + uint32_t * hashTable, uint32_t hashTableSize) { if (entry->labelOffset != RCO_NULL_PTR) { uint32_t *hashPtr = diff --git a/rlzpack.c b/rlzpack.c index 80b60f0..5a1dfa7 100644 --- a/rlzpack.c +++ b/rlzpack.c @@ -34,16 +34,16 @@ int find_match (int *arg_0, unsigned char realMode); typedef struct { // unk_421D80 unsigned char literals[8 * 0xFF]; // grouped in 8 groups of 0xFF; group - // selected by has of input position, - // last byte and mode, the 0xFF part is - // based on the input byte with various - // shifts + // selected by has of input position, + // last byte and mode, the 0xFF part is + // based on the input byte with various + // shifts unsigned char distDescLong[0xF0]; // 30x8 (match >= 4) unsigned char distDescShort[0x40]; // 8x8 (match < 4) unsigned char distances[12 * 0x20]; // grouped in 0x20 based on bit - // position + // position unsigned char lenDesc[0x40]; // 8 x 8; group selected by bit position, - // position is var_C from main function + // position is var_C from main function unsigned char matchlens[0xFF]; void *input; // 0xCA8 @@ -51,15 +51,15 @@ typedef struct { // unk_421D80 // long dword_CB0; // 0xCB0 (0x422A30) - only wrtten to in sub_405810 // long dword_CB4; // 0xCB4 int64_t rangeOffset; // 0xCB0 (0x422A30) - only written to in - // sub_405810(), affected by write_bit and - // write_match_len + // sub_405810(), affected by write_bit and + // write_match_len // - appears to be a data queue - top 24 bits not used, next 8 bits->data to // be written, next 8 bits->data mask; affected by CB8 in some way (CB8 is // added to this) long rangeSize; // 0xCB8 char nextOutputByte; // 0xCBC - some byte offset; 3rd byte in CB0, - // only ever used in sub_405810; guaranteed - // never to == 0xFF + // only ever used in sub_405810; guaranteed + // never to == 0xFF char bytesToWrite; // 0xCBD (0x422A3D) - only used in sub_405810 char writeLock; // 0xCBE - only ever used as a switch char lastSearchBack; // 0xCBF - some byte flag used in find_match() @@ -76,8 +76,8 @@ typedef struct { // unk_421D80 float sgl_120C84; float sgl_120C88; // starts as 0.0625 and increments by that - // amount every time the dictionary coder fails - // to pack stuff + // amount every time the dictionary coder fails + // to pack stuff } RLZ_Info; // about 1.128MB RLZ_Info rlzip; RLZ_Info *rlzi = &rlzip; @@ -96,9 +96,11 @@ rlzcompress (void *output, int inlen, void *input, unsigned char mode) * Bits 45 determine the default values to store in literals/distances etc array * The first 3 bits aren't used */ - int var_C = 0; // var_C appears to do some tracking in regards - // to how well the dictionary coder is packing - // things? + int var_C = 0; // var_C appears to do some tracking in regards + + // + // to how well the dictionary coder is packing + // things? char realMode; int dictSearchBack = 0; // just assign something in case... :S @@ -160,46 +162,49 @@ rlzcompress (void *output, int inlen, void *input, unsigned char mode) // write literal // the following code was previously sub_405A10( (((((unsigned // int)rlzi->inputpos & 7) << 8) | lastInputByte) >> realMode) & 7 ) - int arg_ecx = (((((unsigned int) rlzi->inputpos & 7) << 8) | lastInputByte) >> realMode) & 7; // top - // bit - // in - // (rlzi->inputpos - // & - // 7) - // will - // actually - // be - // discarded - // - - // that - // is, - // (rlzi->inputpos - // & - // 3) - // should - // give - // the - // same - // result + int arg_ecx = (((((unsigned int) rlzi->inputpos & 7) << 8) | lastInputByte) >> realMode) & 7; // top + + // + // bit + // in + // (rlzi->inputpos + // & + // 7) + // will + // actually + // be + // discarded + // - + // that + // is, + // (rlzi->inputpos + // & + // 3) + // should + // give + // the + // same + // result int oldRangeSize = rlzi->rangeSize; unsigned int oldOutputpos = rlzi->outputpos; unsigned int inputVal = *(unsigned char *) ABS_INPUT_POS + 0x100; for (; !(inputVal & 0x10000); inputVal <<= 1) // loop 8 times - write_bit ((unsigned char *) ((unsigned int) rlzi->literals + arg_ecx * 0xFF + (inputVal >> 8) - 1), (inputVal >> 7) & 1); // last - // arg - // (now - // deleted) - // is - // actually - // ebx, - // but - // ebx - // is - // 3 - // at - // this - // time + write_bit ((unsigned char *) ((unsigned int) rlzi->literals + arg_ecx * 0xFF + (inputVal >> 8) - 1), (inputVal >> 7) & 1); // last + // + // arg + // (now + // deleted) + // is + // actually + // ebx, + // but + // ebx + // is + // 3 + // at + // this + // time // these values are only ever used if realMode==7, and only in // find_match() function @@ -227,12 +232,12 @@ rlzcompress (void *output, int inlen, void *input, unsigned char mode) i = 0; if ((searchBackPlus1 & 0xFFFFFFFE) > 0) // if searchBackPlus1 has bits - // other than the first set... - // (that is, searchBackPlus1 != - // 0 && searchBackPlus1 != 1) + // other than the first set... + // (that is, searchBackPlus1 != + // 0 && searchBackPlus1 != 1) { // this condition _should_ always be true, as - // min dictSearchBack is 1, and with +1, min - // value for searchBackPlus1 is 2 + // min dictSearchBack is 1, and with +1, min + // value for searchBackPlus1 is 2 // find the position of the most significant "1" for (i = 2; (searchBackPlus1 >> i) > 0; i++) ; sbSignifBit = --i; // put the bit position in ebp @@ -251,11 +256,11 @@ rlzcompress (void *output, int inlen, void *input, unsigned char mode) int var_esi; do { // write packed thing - perhaps a length of - // next number descriptor? + // next number descriptor? var_esi = ((sbSignifBit & var_edi) > 0 ? 1 : 0); // check if - // certain bit - // in ebp is - // set + // certain bit + // in ebp is + // set write_bit ((unsigned char *) ((unsigned int) &treeStore[var_ebx * 8] + sub_405B90_ret), var_esi); var_edi >>= 1; @@ -277,9 +282,10 @@ rlzcompress (void *output, int inlen, void *input, unsigned char mode) if (matchLen < bytesLeftMinus3) bytesLeftMinus3 = matchLen; - for (i = 0; i < bytesLeftMinus3; i++) // goes thru all the bytes just - // written and pushes some - // things into the dictionary + for (i = 0; i < bytesLeftMinus3; i++) // goes thru all the bytes just + // + // written and pushes some + // things into the dictionary { unsigned int brHash = *(unsigned int *) (ABS_INPUT_POS + i) << 8; @@ -293,13 +299,13 @@ rlzcompress (void *output, int inlen, void *input, unsigned char mode) rlzi->inputpos += matchLen; lastInputByte = *(unsigned char *) (ABS_INPUT_POS - 1); if (rlzi->outputpos == rlzi->inputlen) // is the compressed output - // larger than the original - // stream? + // larger than the original + // stream? return -1; } write_match_len (0xFF, var_C); // end marker or is this used for - // flushing data? + // flushing data? { // originally sub_4058E0() i = (rlzi->writeLock ? 5 : 4); @@ -322,7 +328,8 @@ write_match_len (unsigned char len, unsigned int arg_4) // arg_4 -> something // that keeps track of // no. past blocks // packed with - // find_match() (always + // find_match() (always + // // var_C from // rlzcompress()) { @@ -343,8 +350,8 @@ write_match_len (unsigned char len, unsigned int arg_4) // arg_4 -> something } i--; if (i > 0) // --> identical to if(len != 0); this will - // only be true if len >= 1 (or len<0) - eg if - // data was packed + // only be true if len >= 1 (or len<0) - eg if + // data was packed { i--; unsigned char *ptr = rlzi->matchlens + ((arg_4 & 7) + i * 8) * 4; @@ -409,8 +416,9 @@ write_special (unsigned char *unk0ptr, int num, int arg_edx) rlzi->rangeOffset += rangeTmp; } } - arg_edx += 3; // 2 (reverse previous subtraction), and +1 for - // the above loop + arg_edx += 3; // 2 (reverse previous subtraction), and +1 for + // + // the above loop rlzi->rangeSize = (long) rangeTmp; write_output (); } @@ -431,9 +439,10 @@ flush_output (void) // 0x00000000FF?????? if ((rlzi->rangeOffset >> 0x18) != 0xFF) { unsigned char byteOut = rlzi->nextOutputByte; // starts off as 0, - // then becomes 3rd - // byte of - // rlzi->rangeOffset + + // then becomes 3rd + // byte of + // rlzi->rangeOffset rlzi->nextOutputByte = (rlzi->rangeOffset >> 0x18) & 0xFF; do { @@ -449,7 +458,8 @@ flush_output (void) } // loc_4058A4: rlzi->bytesToWrite++; - // rlzi->rangeOffset = (arg_CB0 << 8) & 0xFFFFFFFF; // make sure high 32 bits + // rlzi->rangeOffset = (arg_CB0 << 8) & 0xFFFFFFFF; // make sure high 32 bits + // // are 0 // rlzi->rangeSize = arg_CB8 << 8; rlzi->rangeOffset <<= 8; @@ -469,7 +479,8 @@ write_output (void) // sub_405CE0: arg_0 = buf // this function determines how much data we can pack into a single byte // return of 1 = can't compress; don't think this can return 0xFF or higher -// NEW: this function searches for distance-length, but doesn't actually encode +// NEW: this function searches for distance-length, but doesn't actually encode +// // anything int find_match (int *searchBackUsed, unsigned char realMode) @@ -486,22 +497,24 @@ find_match (int *searchBackUsed, unsigned char realMode) if (bytesLeft < 2) return 1; if (bytesLeft < 0xFF) // if we have less bytes left than the maximum - // block size + // block size maxBlockSize = bytesLeft; - // realMode7Threshold = ((unsigned int)(rlzi->sgl_120C84 / rlzi->sgl_120C88 + + // realMode7Threshold = ((unsigned int)(rlzi->sgl_120C84 / rlzi->sgl_120C88 + + // // 128.5) > 0x64); //dbl_41A3B8 // realMode7Threshold = ((int)((unsigned int)(rlzi->sgl_120C84 / // rlzi->sgl_120C88 + 128.5)) > 0x64); #define ROUND(n) ((int)((n) + 0.5)) realMode7Threshold = (ROUND (rlzi->sgl_120C84 / rlzi->sgl_120C88) > -28); - // the second line above generates output consistent with the good rlzpacker, + // the second line above generates output consistent with the good rlzpacker, + // // but is this typecasting all correct? // check if we have a continuous copy of something searchBack = ABS_INPUT_POS - rlzi->lastSearchBack; // byte_CBF only used - // by find_match(); is - // initially 0 + // by find_match(); is + // initially 0 if ((unsigned int) rlzi->lastSearchBack < rlzi->inputpos && *(unsigned char *) (searchBack - 1) == *(unsigned char *) (ABS_INPUT_POS) && *(unsigned char *) (searchBack) == @@ -534,7 +547,8 @@ find_match (int *searchBackUsed, unsigned char realMode) // loc_405DB7: // if we have 2 bytes left in the buffer (remember, if there's 1 byte left, // this function would've - // already returned), we'll either by able to pack 1 or 2 bytes into a single + // already returned), we'll either by able to pack 1 or 2 bytes into a single + // // byte // We can pack 2 bytes into a byte if repeat bytes (above) have been found. if (maxBlockSize < 3) { @@ -543,16 +557,17 @@ find_match (int *searchBackUsed, unsigned char realMode) // loc_405DC9: // edx = ABS_INPUT_POS; - never actually read... unsigned int brHash = *(unsigned int *) ABS_INPUT_POS << 8; // previously - // eax + + // eax backRef = rlzi->window[(unsigned int) brHash % RLZI_WINDOW_SIZE]; while (backRef != -1) { // found a back reference if (backRef < (int) (rlzi->inputpos - RLZI_DICTIONARY_SIZE - 1)) // is - // the - // backreference - // out - // of - // bounds? + // the + // backreference + // out + // of + // bounds? break; unsigned int matchAmt = matchLen + 1; @@ -562,8 +577,8 @@ find_match (int *searchBackUsed, unsigned char realMode) if (*(unsigned char *) ((unsigned int) rlzi->input + backRef + i) != *(unsigned char *) (ABS_INPUT_POS + i)) goto loc_405F97; // jumps to end of while-loop (not valid - - // search for more references which could be - // valid) + // search for more references which could be + // valid) } // see how much more we can match @@ -576,7 +591,7 @@ find_match (int *searchBackUsed, unsigned char realMode) break; } i = rlzi->inputpos - backRef - 1; // distance? penalising short matches - // which have a large distance?? + // which have a large distance?? if (matchAmt >= 3 && (matchAmt != 3 || (i <= 0x7F && (i <= 0x30 || realMode != 5)))) { tempCompare = 0; @@ -621,7 +636,7 @@ find_match (int *searchBackUsed, unsigned char realMode) // loc_405F60: for (i = 3; i < matchAmt; i++) // loop max of 6 times due to - // code below + // code below { if (i != 3 || (*searchBackUsed <= 0x7F && (*searchBackUsed <= 0x30 || realMode != 5))) { @@ -656,9 +671,9 @@ find_match (int *searchBackUsed, unsigned char realMode) return maxBlockSize; // since maxBlockSize <= 0xFF, this implies maxBlockSize==0xFF if (bytesLeft <= 0xFF) // if bytesLeft < 0xFF, then - // maxBlockSize < 0xFF will be true - // (enforced above), thus this line is - // essentially "if(bytesLeft == 0xFF)" + // maxBlockSize < 0xFF will be true + // (enforced above), thus this line is + // essentially "if(bytesLeft == 0xFF)" { return 0xFD; // or 0x100 - 3 } diff --git a/vaghandler.c b/vaghandler.c index 258b4de..2ae0ad1 100644 --- a/vaghandler.c +++ b/vaghandler.c @@ -30,10 +30,10 @@ const double f[5][2] = { {0.0, 0.0}, #define VAG_SIGNATURE 0x70474156 #define VAG_VERSION 0x4000000 // 0x2000000 PACK_STRUCT (VagHeader, { - uint32_t signature; // "VAGp" + uint32_t signature; // "VAGp" uint32_t version; // 0x20 - uint32_t reserved; // 0 - uint32_t dataSize; // size of file - 0x30 + uint32_t reserved; // 0 + uint32_t dataSize; // size of file - 0x30 uint32_t frequency; uint8_t reserved2[12]; // 0 char name[16]; @@ -53,20 +53,22 @@ PACK_STRUCT (VagChunk, { #define WAV_PCM_FORMAT 1 #define WAV_S2_SIG 0x61746164 PACK_STRUCT (WavHeader, { - uint32_t signature; // "RIFF" + 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 audioFmt; // PCM = 1 uint16_t channels; uint32_t frequency; - uint32_t byterate; // = frequency * channels * bitDepth/8 + uint32_t byterate; // = frequency + // * channels * + // bitDepth/8 uint16_t sampleSize; // = channels * bitDepth / 8 - uint16_t bitDepth; // we'll always use 16 + uint16_t bitDepth; // we'll always use 16 uint32_t s2sig; // "data" uint32_t s2size; // = numSamples * channels * bitDepth/8 OR - // size-36 + // size-36 }); // TODO: sanity checks with lengths @@ -117,8 +119,8 @@ vag2wav (const char *fWav, int numChannels, int *vagLen, void **vagData) // take a guess at the length (we'll fix these later if wrong) - make // assumption that all channels are of same size - wh.s2size = (((*vagLen - sizeof (VagHeader)) / sizeof (VagChunk)) - 1) * 28 /* samples - */ * 2 /* 16bit */ * numChannels; + wh.s2size = (((*vagLen - sizeof (VagHeader)) / sizeof (VagChunk)) - 1) * 28 /* samples */ * 2 /* 16bit + */ * numChannels; wh.size = wh.s2size + 28; filewrite (fp, &wh, sizeof (wh)); @@ -320,7 +322,8 @@ wav2vag (const char *fWav, uint32_t * len, void **vagData, const char *vagName) // pack // I don't understand it, but it seems that the second transformation is - // required to prevent a clipping sound effect although it should produce + // required to prevent a clipping sound effect although it should produce + // // worse reconverts... int8_t outBuf[28]; @@ -347,8 +350,8 @@ wav2vag (const char *fWav, uint32_t * 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_t if(s & 0x8000) s |= 0xFFFF0000; double sample = - * (double)(s >> shift) + factors2[ch*2] * f[predict][0] + + * 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_t)ROUND(sample)) { printf("a"); } } } */ @@ -372,15 +375,15 @@ wav2vag (const char *fWav, uint32_t * len, void **vagData, const char *vagName) return wh.channels; } -/* +/* * 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)); - * + * * #define WAV2VAG_ERROR_EXIT(s) { \ error(s, fWav); \ fclose(fp); \ return 0; * \ } - * + * * if(wh.signature != WAV_SIGNATURE || wh.format != WAV_FORMAT) * WAV2VAG_ERROR_EXIT("File '%s' not a valid WAV file, conversion aborted.") * if(wh.s1sig != WAV_S1_SIG || wh.s1size != WAV_S1_SIZE_PCM || wh.s2sig != @@ -388,37 +391,37 @@ wav2vag (const char *fWav, uint32_t * len, void **vagData, const char *vagName) * rcomage's VAG handler; conversion aborted.") if(wh.audioFmt != * WAV_PCM_FORMAT || wh.bitDepth != 16) WAV2VAG_ERROR_EXIT("rcomage's VAG * handler only supports 16-bit PCM data, file '%s' not converted.") - * + * * if(wh.channels > 9) WAV2VAG_ERROR_EXIT("Channels number too high for '%s'.") - * - * //if(wh.s2size != wh.size-36 || wh.size+8 != filesize(fWav) || wh.sampleSize + * + * //if(wh.s2size != wh.size-36 || wh.size+8 != filesize(fWav) || wh.sampleSize * != wh.channels*wh.bitDepth/8) // WAV2VAG_ERROR_EXIT("Bad size values in WAV * header for '%s'.") - * - * + * + * * 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); - * + * * for(i=0; isignature = VAG_SIGNATURE; - * vh->version = VAG_VERSION; vh->reserved = 0; vh->dataSize = ENDIAN_SWAP(*len + * vh->version = VAG_VERSION; vh->reserved = 0; vh->dataSize = ENDIAN_SWAP(*len * - 0x30); vh->frequency = ENDIAN_SWAP(wh.frequency); strncpy(vh->name, * vagName, 16); } - * - * uint32_t pos; int wavBufSize = 28 * (wh.bitDepth/8) * wh.channels; int16_t* wavBuf + * + * 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_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 + * 0xfffff000; if(sample2 > 32767) sample2 = 32767; if(sample2 < -32768) sample2 * = -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); } } - * + * * free(wavBuf); free(factors); free(factors2); - * + * * // put terminating chunk for(i=0; ipredict_shift = 0; vc->flags = 7; memset(&vc->s, 0x77, 14); } - * + * * fclose(fp); return wh.channels; } */ diff --git a/vaghandler.h b/vaghandler.h index b77d161..8c90ed1 100644 --- a/vaghandler.h +++ b/vaghandler.h @@ -10,6 +10,8 @@ #ifndef __VAGHANDLER__ #define __VAGHANDLER__ #include "general.h" -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); +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); #endif diff --git a/vsmx.c b/vsmx.c index c6806d3..a902291 100644 --- a/vsmx.c +++ b/vsmx.c @@ -61,7 +61,7 @@ enum { VID_OPERATOR_EQUAL = 0xe, VID_OPERATOR_NOT_EQUAL = 0xf, VID_OPERATOR_CASE_LABEL = 0x10, // same as VID_OPERATOR_EQUAL, just - // used in switch statements + // used in switch statements VID_OPERATOR_LT = 0x12, VID_OPERATOR_LTE = 0x13, @@ -88,9 +88,9 @@ enum { VID_PROPERTY = 0x2f, VID_METHOD = 0x30, VID_UNK_31 = 0x31, // appears to be an object set; pops last two - // items off the stack + // items off the stack VID_UNSET = 0x32, // guess; looks like above, but only with one - // item + // item VID_ARRAY_INDEX = 0x34, @@ -98,8 +98,8 @@ enum { VID_ARRAY_ELEM = 0x38, // push something into array constant VID_SECT_START = 0x39, // jump statement; can indicate end of - // function, end of else/for, or return to - // beginning of loop + // function, end of else/for, or return to + // beginning of loop VID_JUMP_TRUE = 0x3a, // jump if previous value is true VID_JUMP_FALSE = 0x3b, VID_CALL_FUNC = 0x3c, @@ -712,9 +712,9 @@ VsmxEncode (FILE * in) #define IS_WHITESPACE(x) (x == L'\t' || x == L' ' || x == L'\n' || x == L'\r') while (*op && IS_WHITESPACE (*op)) op++; - /* code is BAD - can remove stuff if in a string! // don't forget to remove - * comments! tmp = op; while(*tmp) { if(*tmp == L';') { *tmp = L'\0'; - * break; } tmp++; } */ + /* code is BAD - can remove stuff if in a string! // don't forget to remove + * comments! tmp = op; while(*tmp) { if(*tmp == L';') { *tmp = L'\0'; break; + * * } tmp++; } */ lineLen = wcslen (op); while (lineLen && IS_WHITESPACE (op[lineLen - 1])) lineLen--; @@ -1258,7 +1258,7 @@ VsmxDecompile (VsmxMem * in, FILE * out) case VID_UNK_31: CHECK_INDEX (in->numProp, "prop"); if (stack && stack->depth >= 1) { // TODO: this is really not - // correct + // correct VsmxDecompileStack *obj, *val; val = VsmxDecompileStackPop (&stack); @@ -1666,9 +1666,10 @@ VsmxDecompile (VsmxMem * in, FILE * out) } else { // function start - SWPRINTF (op, 50, L"%%ls { /* ends at %d */\n", in->code[i].val.u32); // wcscpy(op, - // L"%s - // {\n"); + SWPRINTF (op, 50, L"%%ls { /* ends at %d */\n", in->code[i].val.u32); // wcscpy(op, + // + // L"%s + // {\n"); } } case VID_JUMP_FALSE: @@ -1682,11 +1683,12 @@ VsmxDecompile (VsmxMem * in, FILE * out) if (in->code[in->code[i].val.u32 - 1].id == VID_SECT_START && in->code[in->code[i].val.u32 - 1].val.u32 == stmtStart) { // while loop - SWPRINTF (op, 50, L"while( %%s ) { /* ends at %d */\n", in->code[i].val.u32); // wcscpy(op, - // L"while( - // %s - // ) - // {\n"); + SWPRINTF (op, 50, L"while( %%s ) { /* ends at %d */\n", in->code[i].val.u32); // wcscpy(op, + // + // L"while( + // %s + // ) + // {\n"); } else { // if statement if (stack->depth > endStmtConcat - 1) { @@ -1710,11 +1712,12 @@ VsmxDecompile (VsmxMem * in, FILE * out) VsmxDecompMarkStackPush (&mStack, &mItem); break; } else { - SWPRINTF (op, 50, L"if( %%s ) { /* ends at %d */\n", in->code[i].val.u32); // wcscpy(op, - // L"if( - // %s - // ) - // {\n"); + SWPRINTF (op, 50, L"if( %%s ) { /* ends at %d */\n", in->code[i].val.u32); // wcscpy(op, + // + // L"if( + // %s + // ) + // {\n"); } } } diff --git a/xml.h b/xml.h index 74b6a24..b5d7388 100644 --- a/xml.h +++ b/xml.h @@ -19,8 +19,10 @@ rRCOFile *read_xml (char *fn); #define RCOXML_TABLE_2ND_DIM 20 typedef char ((*RcoTableMap)[RCOXML_TABLE_2ND_DIM]); // doesn't make + // sense... I want a - // pointer to an array, + // pointer to an array, + // // not an array of // pointers... extern RcoTableMap RCOXML_TABLE_DATA_COMPRESSION; diff --git a/xmlread.c b/xmlread.c index 42f0b48..9d72307 100644 --- a/xmlread.c +++ b/xmlread.c @@ -26,7 +26,7 @@ #define strtof(a,b) (float)strtod(a,b) -/* +/* * typedef struct { rRCORef* ref; char* label; } xmlrco_read_fix_refs; */ typedef struct { // xmlChar *ptrText, *ptrImg, *ptrSound, *ptrModel, *ptrObj, *ptrAnim; @@ -42,8 +42,8 @@ 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, uint32_t * labelPos, rRCOFile * rco, - rRCOEntry * entry); +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); @@ -108,7 +108,7 @@ read_xml (char *fn) xmlNodePtr nodeChild; if (bValidDoc) { // valid document must contain at least one - // thing under RcoFile (MainTree) + // thing under RcoFile (MainTree) nodeChild = node->xmlChildrenNode; while (nodeChild->next && nodeChild->type != XML_ELEMENT_NODE) nodeChild = nodeChild->next; @@ -214,12 +214,13 @@ read_xml (char *fn) rco->eSwap = rco->ps3; - /* + /* * rco->tblMain.id = rco->tblMain.type = 0; rco->tblMain.labelOffset = 0; * rco->tblMain.numSubentries = rco->tblMain.extraLen = 0; */ parse_entry (nodeChild, &(rco->tblMain), rco, &fixes); - // TODO: ensure the first table _is_ the main table (and possibly then verify + // TODO: ensure the first table _is_ the main table (and possibly then verify + // // tree structure) // - post fixes - @@ -355,31 +356,32 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, &(entry->srcLen), compr) >= 2) { entry->srcLen -= entry->srcAddr; entry->srcLenUnpacked = entry->srcLen; // default - assume no - // compression + // compression if (compr[0]) { // TODO: handle situations where uncompressed size is not // specified - if (sscanf (compr, ";zlib[%u]", &(entry->srcLenUnpacked)) == 1) { // TODO: - // a - // temporary - // fix - // (prolly - // need - // to - // add - // more - // compression - // algos, - // since - // sscanf - // seems - // to - // be - // rather - // basic - // in - // retrieving - // %s) + if (sscanf (compr, ";zlib[%u]", &(entry->srcLenUnpacked)) == 1) { // TODO: + // + // a + // temporary + // fix + // (prolly + // need + // to + // add + // more + // compression + // algos, + // since + // sscanf + // seems + // to + // be + // rather + // basic + // in + // retrieving + // %s) rcoxml_text_to_int ("zlib", RCOXML_TABLE_DATA_COMPRESSION, &(entry->srcCompression)); } else if (!strcmp (compr, ";rco")) { @@ -394,13 +396,14 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, xmlFree (src); } else { entry->srcAddr = 0; - entry->srcLen = entry->srcLenUnpacked = filesize (entry->srcFile); // won't - // work - // if - // filename - // contains - // a - // '*' + entry->srcLen = entry->srcLenUnpacked = filesize (entry->srcFile); // won't + // + // work + // if + // filename + // contains + // a + // '*' } } } @@ -539,7 +542,8 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, srcBufferTmp = realloc (srcBufferTmp, curPos + ALIGN_TO_4 (se->channelData[i * 2])); - uint8_t *bufferPos = (uint8_t *) (srcBufferTmp) + curPos; + uint8_t *bufferPos = + (uint8_t *) (srcBufferTmp) + curPos; fileread (fp, bufferPos, se->channelData[i * 2]); fclose (fp); @@ -673,11 +677,12 @@ parse_entry (xmlNodePtr node, rRCOEntry * entry, rRCOFile * rco, if (fp) { // do we have a BOM? - unsigned char bom[4] = { 0x80, 0x80, 0x80, 0x80 }; // dummy - // values - // that - // aren't - // used + unsigned char bom[4] = { 0x80, 0x80, 0x80, 0x80 }; // dummy + // + // values + // that + // aren't + // used char srcFmt[10] = "", destFmt[8]; uint32_t bom32le = UTF32_BOM; uint32_t bom32be = ENDIAN_SWAP (UTF32_BOM); @@ -759,10 +764,10 @@ 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_t* bufferPos - * = (uint8_t*)srcBufferTmp + curPos; fileread(fp, - * bufferPos, te->indexes[i].length-2); // add - * terminating null & any necessary padding + * 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, * ALIGN_TO_4(te->indexes[i].length) - * (te->indexes[i].length-2)); } */ @@ -928,7 +933,8 @@ rcoxml_text_to_int (char *s, const RcoTableMap map, uint32_t * out) // currently very basic - resize when adding a label // uint32_t rcoxml_add_label(rRCOFile* rco, char* label) { uint32_t -rcoxml_add_label (char **labels, uint32_t * labelsLen, char *label, uint8_t eventQuirk) +rcoxml_add_label (char **labels, uint32_t * labelsLen, char *label, + uint8_t eventQuirk) { // first, see if we already have this label uint32_t p = 0; @@ -938,11 +944,11 @@ rcoxml_add_label (char **labels, uint32_t * labelsLen, char *label, uint8_t even return p; // found p += strlen (*labels + p) + 1; p = ALIGN_TO_4 (p); // urgh, this is kinda a little dirty, but it - // works; if we hit a blank 4 bytes, the above - // line will cause it to go forward by 1, this - // will align it forward to 4, so, if we've hit - // some nulls, we're effectively jumping 4 - // bytes at a time + // works; if we hit a blank 4 bytes, the above + // line will cause it to go forward by 1, this + // will align it forward to 4, so, if we've hit + // some nulls, we're effectively jumping 4 + // bytes at a time } // don't have it? add it @@ -950,7 +956,7 @@ rcoxml_add_label (char **labels, uint32_t * labelsLen, char *label, uint8_t even uint32_t labelLen = strlen (label) + 1; if (eventQuirk) { - // TODO: + // TODO: } uint32_t newLen = curLen + labelLen; @@ -963,10 +969,10 @@ rcoxml_add_label (char **labels, uint32_t * labelsLen, char *label, uint8_t even } *labelsLen = newLen; - /* - * uint32_t curLen = rco->labelsLen; uint32_t 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); * rco->labelsLen = newLen; */ return curLen; @@ -983,7 +989,7 @@ rcoxml_add_label_reordering (char *newLabels, uint32_t * labelPos, char *label) return p; // found p += strlen (newLabels + p) + 1; p = ALIGN_TO_4 (p); // dirty, but it works (see note from - // rcoxml_add_label) + // rcoxml_add_label) } // don't have it? add it @@ -1039,7 +1045,8 @@ parse_obj_extra (xmlNodePtr node, rRCOEntry * entry) // work out the length of this thing, lol 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++) { + 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_t); entry->extraLen += sizeof (rRCORef); @@ -1118,9 +1125,9 @@ parse_obj_extra (xmlNodePtr node, rRCOEntry * entry) warning ("[line %d] Unable to parse reference '%s' - defaulting to 'nothing'.", node->line, (char *) val); - /* + /* * // we really need to fix refs after all entries are loaded - I'm - * going to be lazy here since we can't actually do anything terribly + * going to be lazy here since we can't actually do anything terribly * useful right now ((rRCORef*)extra)->type = RCO_REF_NONE; * add_ref_to_fix(fixes, , (rRCORef*)extra); */ } else { @@ -1150,7 +1157,8 @@ parse_anim_extra (xmlNodePtr node, rRCOEntry * entry) // work out the length of this thing, lol 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++) { + 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_t); entry->extraLen += sizeof (rRCORef); @@ -1229,9 +1237,9 @@ parse_anim_extra (xmlNodePtr node, rRCOEntry * entry) warning ("[line %d] Unable to parse reference '%s' - defaulting to 'nothing'.", node->line, (char *) val); - /* + /* * // we really need to fix refs after all entries are loaded - I'm - * going to be lazy here since we can't actually do anything terribly + * going to be lazy here since we can't actually do anything terribly * useful right now ((rRCORef*)extra)->type = RCO_REF_NONE; * add_ref_to_fix(fixes, , (rRCORef*)extra); */ } else { @@ -1251,49 +1259,49 @@ 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) { uint32_t i = 0; - * - * entry->extraLen = 0; for(i=0, i2=0; i<(uint32_t)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_t); } - * + * * //if(RCO_ANIM_EXTRA_REFS[entry->type]) { // entry->extraLen = * (RCO_ANIM_EXTRA_LEN[entry->type]-2) * sizeof(uint32_t) + sizeof(rRCORef); //} * else { // entry->extraLen = RCO_ANIM_EXTRA_LEN[entry->type] * * sizeof(uint32_t); //} - * + * * entry->extra = malloc(entry->extraLen); uint8_t* extra = (uint8_t*)entry->extra; * memset(extra, 0, entry->extraLen); - * + * * uint32_t entryLen = (uint32_t)RCO_ANIM_EXTRA_LEN[entry->type]; - * - * if(RCO_ANIM_EXTRA_REFS[entry->type]) { xmlChar* val = NULL; if(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 = * xmlGetProp(node, _X("object")); - * + * * if(val) { if(!rcoxml_parse_ref((char*)val, (rRCORef*)extra)) warning("[line * %d] Unable to parse object reference '%s' - defaulting to 'nothing'.", * node->line, (char*)val); } else { warning("[line %d] No object/event defined * for anim entry. Defaulting to nothing.", node->line); // blank ref rRCORef* - * dr = ((rRCORef*)extra); dr->type = RCO_REF_NONE; dr->ptr = NULL; dr->rawPtr = + * dr = ((rRCORef*)extra); dr->type = RCO_REF_NONE; dr->ptr = NULL; dr->rawPtr = * RCO_NULL_PTR; } extra += sizeof(rRCORef); entryLen -=2; } - * + * * for(i=0; itype][i][0]) { val = xmlGetProp(node, * _X(RCO_ANIM_EXTRA_NAMES[entry->type][i])); } if(!val) { val = * rcoxml_get_unknown_attrib(node, i); } - * + * * if(!val) { if(RCO_ANIM_EXTRA_NAMES[entry->type][i][0]) { warning("[line %d] * 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_t*)extra = 0; } else { *(uint32_t*)extra = * rcoxml_parse_value((char*)val); xmlFree(val); } - * + * * extra += sizeof(uint32_t); } } else { // TODO: handle unknown types } } */ // TODO: this somewhat mixes normal vals with refs (not optimal) - may wish to @@ -1378,10 +1386,10 @@ rcoxml_parse_ref (char *val, rRCORef * out) if (out->type == RCO_REF_NONE) { // not assigned by above ifs if (sscanf (val, "unknown%i", (int *) &(out->type))) { // this is - // actually - // case - // sensitive... - // :| + // actually + // case + // sensitive... + // :| out->rawPtr = strtol (colon, NULL, 10); return TRUE; } else { @@ -1395,16 +1403,16 @@ rcoxml_parse_ref (char *val, rRCORef * out) return TRUE; } -/* +/* * // a very simple resize method :/ void add_ref_to_fix(rcoxml_read_fixes* * fixes, char* label, rRCORef* ref) { fixes->refs = * (xmlrco_read_fix_refs*)realloc(fixes->refs, sizeof(xmlrco_read_fix_refs) * * (fixes->refCnt+1)); xmlrco_read_fix_refs* fr = * &(fixes->refs[fixes->refsCnt]); - * - * fr->ref = ref; fr->label = (char*)malloc(strlen(label)+1); strcpy(fr->label, + * + * fr->ref = ref; fr->label = (char*)malloc(strlen(label)+1); strcpy(fr->label, * label); - * + * * fixes->refsCnt++; } */ void @@ -1435,12 +1443,12 @@ rcoxml_fix_refs (rRCOEntry * entry, rRCOFile * rco) } else 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_t); } - * + * * } else { // anim entries if(RCO_ANIM_EXTRA_REFS[entry->type]) { * rcoxml_fix_ref((rRCORef*)extra, rco); } } */ } @@ -1541,7 +1549,7 @@ rcoxml_fix_ptrs (rRCOEntry *** sect, uint32_t * sectCnt, rRCOFile * rco, uint32_t i; - /* + /* * for(i=0; iindexes[i].length = (xmlUTF8Strlen (n) + 1 /* null */ ) * charWidth; if ((*(uint32_t *) n & 0xFFFFFF) == UTF8_BOM) { // fix for - // older - // versions of - // rcomage - if - // BOM exists, - // reduce - // length by 1 - // char + // older + // versions of + // rcomage - if + // BOM exists, + // reduce + // length by 1 + // char te->indexes[i].length -= charWidth; } } @@ -1768,8 +1777,8 @@ parse_text_xml (char *fn, rRCOFile * rco, rRCOEntry * entry) iconv (ic, (char **) (&n), (size_t *) (&contentLen), &tbPtr, (size_t *) (&outBufLen)); if (outBufLen && outBufLen == charWidth) { // *should* - // always be - // true + // always be + // true memset (tbPtr, 0, ALIGN_TO_4 (te->indexes[i].length) - (te->indexes[i].length - outBufLen)); diff --git a/xmlwrite.c b/xmlwrite.c index d156a87..581ca0b 100644 --- a/xmlwrite.c +++ b/xmlwrite.c @@ -18,8 +18,9 @@ #define IMP(a,b) (!(a) || (b)) // logical implication, ie, a implies b -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 (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_t type, uint8_t * info, rRCOFile * rco, @@ -109,7 +110,7 @@ xmlwrite_entry (rRCOEntry * entry, uint32_t depth, rRCOFile * rco, FILE * fp, sprintf (tagName, "Unknown_0x%x_0x%x", entry->id, entry->type); } - /* + /* * switch(entry->id) { case RCO_TABLE_MAIN: strcpy(tagName, "Main"); break; * case RCO_TABLE_IMG: strcpy(tagName, "Image"); break; case RCO_TABLE_SOUND: * strcpy(tagName, "Sound"); break; case RCO_TABLE_MODEL: strcpy(tagName, @@ -126,7 +127,7 @@ xmlwrite_entry (rRCOEntry * entry, uint32_t depth, rRCOFile * rco, FILE * fp, * RCO_TABLE_ANIM: if(entry->type <= RCO_ANIM_EXTRA_LEN_NUM) { char* * animTags[] = {"Anim", "Animation", "Move", "ColourChange", "Rotate", * "Resize", "Fade", "Delay", "FireEvent", "Lock", "Unlock", "UnknownB"}; - * tagName = animTags[entry->type]; } else sprintf(tagName, "AnimUnknown0x%x", + * tagName = animTags[entry->type]; } else sprintf(tagName, "AnimUnknown0x%x", * entry->type); break; } */ for (i = 0; i < depth; i++) @@ -168,22 +169,22 @@ xmlwrite_entry (rRCOEntry * entry, uint32_t depth, rRCOFile * rco, FILE * fp, } // extra attribs if (isMainTable) { - /* + /* * // 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->ptrObj; numPtrs = rco->numPtrObj; break; case RCO_TABLE_ANIM: ptrs = * rco->ptrAnim; numPtrs = rco->numPtrAnim; break; } if(numPtrs) { uint32_t j; * fputs(" ptrorder=\"", fp); for(i=0; iid == RCO_TABLE_TEXT) { - * rRCOTextIdxPtr* tip = &(((rRCOTextIdxPtr*)ptrs)[i]); if(tip->textEntry && + * rRCOTextIdxPtr* tip = &(((rRCOTextIdxPtr*)ptrs)[i]); if(tip->textEntry && * tip->index) { char tmp[30]; * rcoxml_int_to_text(((rRCOTextEntry*)tip->textEntry->extra)->lang, * RCOXML_TABLE_TEXT_LANG, tmp); fprintf(fp, "%s:%s", tmp, rco->labels + @@ -332,10 +333,10 @@ xmlwrite_entry_extra_object (uint16_t type, uint8_t * info, rRCOFile * rco, return; // TODO: handle unknown object types? for (i = 0, i2 = 0; i < numEntries; i++, i2++) { // i2 doesn't include - // the position entry, - // plus doesn't - // increase twice for a - // reference + // the position entry, + // plus doesn't + // increase twice for a + // reference // is this entry a reference? uint8_t isRef = RCO_OBJ_IS_REF (type, i2); @@ -396,12 +397,13 @@ xmlwrite_entry_extra_object (uint16_t type, uint8_t * info, rRCOFile * rco, fputs ("\"", fp); if (isRef) i++; // need to do this since the tables consider - // refs to take two entries + // refs to take two entries } } void -xmlwrite_entry_extra_anim (uint16_t type, uint8_t * 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]; @@ -411,10 +413,10 @@ xmlwrite_entry_extra_anim (uint16_t type, uint8_t * info, rRCOFile * rco, FILE * return; // TODO: handle unknown object types? for (i = 0, i2 = 0; i < numEntries; i++, i2++) { // i2 doesn't include - // the position entry, - // plus doesn't - // increase twice for a - // reference + // the position entry, + // plus doesn't + // increase twice for a + // reference // is this entry a reference? uint8_t isRef = RCO_ANIM_IS_REF (type, i2); @@ -475,35 +477,35 @@ xmlwrite_entry_extra_anim (uint16_t type, uint8_t * info, rRCOFile * rco, FILE * fputs ("\"", fp); if (isRef) i++; // need to do this since the tables consider - // refs to take two entries + // refs to take two entries } } -/* +/* * 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? - * + * * // TODO: this method makes the number following unknown tag names disregard * the reference (should fix this) if(RCO_ANIM_EXTRA_REFS[type]) { if(type == * RCO_ANIM_TYPE_EVENT) fputs(" event=\"", fp); else fputs(" object=\"", fp); * xml_fputref((rRCORef*)info, rco, fp); fputs("\"", fp); - * + * * info += sizeof(rRCORef); numEntries -= 2; } - * - * for(i=0; iptr))->labelOffset + rco->labels, fp); else fputs ("", fp); // TODO: handle situations where there isn't a - // label... + // label... } } -- 2.39.5