diff --git a/Makefile b/Makefile index 046fc6802a..47f82a7c24 100644 --- a/Makefile +++ b/Makefile @@ -569,9 +569,9 @@ ifeq ($(PLATFORM),IQUE) # Some files are compiled with EGCS on iQue EGCS_O_FILES += $(BUILD_DIR)/src/boot/boot_main.o EGCS_O_FILES += $(BUILD_DIR)/src/boot/idle.o +EGCS_O_FILES += $(BUILD_DIR)/src/boot/inflate.o EGCS_O_FILES += $(BUILD_DIR)/src/boot/z_locale.o EGCS_O_FILES += $(BUILD_DIR)/src/boot/z_std_dma.o -EGCS_O_FILES += $(BUILD_DIR)/src/boot/zlib.o # EGCS_O_FILES += $(BUILD_DIR)/src/code/z_actor.o EGCS_O_FILES += $(BUILD_DIR)/src/code/z_common_data.o EGCS_O_FILES += $(BUILD_DIR)/src/code/z_construct.o diff --git a/include/functions.h b/include/functions.h index 7a114f73c5..092616bcee 100644 --- a/include/functions.h +++ b/include/functions.h @@ -12,7 +12,11 @@ void ViConfig_UpdateBlack(void); void* Yaz0_FirstDMA(void); void* Yaz0_NextDMA(u8* curSrcPos); void Yaz0_DecompressImpl(u8* src, u8* dst); +#if !PLATFORM_IQUE void Yaz0_Decompress(uintptr_t romStart, u8* dst, size_t size); +#else +void gzip_decompress(uintptr_t romStart, u8* dst, size_t size); +#endif void Locale_Init(void); void Locale_ResetRegion(void); #if DEBUG_FEATURES diff --git a/spec b/spec index 4260c50016..f68610d9ea 100644 --- a/spec +++ b/spec @@ -23,7 +23,11 @@ beginseg #endif include "$(BUILD_DIR)/src/boot/carthandle.o" include "$(BUILD_DIR)/src/boot/z_std_dma.o" +#if !PLATFORM_IQUE include "$(BUILD_DIR)/src/boot/yaz0.o" +#else + include "$(BUILD_DIR)/src/boot/inflate.o" +#endif include "$(BUILD_DIR)/src/boot/z_locale.o" #if PLATFORM_N64 include "$(BUILD_DIR)/src/boot/cic6105.o" diff --git a/src/boot/inflate.c b/src/boot/inflate.c new file mode 100644 index 0000000000..c0467dd38c --- /dev/null +++ b/src/boot/inflate.c @@ -0,0 +1,1003 @@ +/* Not copyrighted 1992 by Mark Adler + version c10p1, 10 January 1993 */ + +/* You can do whatever you like with this source file, though I would + prefer that if you modify it and redistribute it that you include + comments to that effect with your name and the date. Thank you. + [The history has been moved to the file ChangeLog.] + */ + +/* + Inflate deflated (PKZIP's method 8 compressed) data. The compression + method searches for as much of the current string of bytes (up to a + length of 258) in the previous 32K bytes. If it doesn't find any + matches (of at least length 3), it codes the next byte. Otherwise, it + codes the length of the matched string and its distance backwards from + the current position. There is a single Huffman code that codes both + single bytes (called "literals") and match lengths. A second Huffman + code codes the distance information, which follows a length code. Each + length or distance code actually represents a base value and a number + of "extra" (sometimes zero) bits to get to add to the base value. At + the end of each deflated block is a special end-of-block (EOB) literal/ + length code. The decoding process is basically: get a literal/length + code; if EOB then done; if a literal, emit the decoded byte; if a + length then get the distance and emit the referred-to bytes from the + sliding window of previously emitted data. + + There are (currently) three kinds of inflate blocks: stored, fixed, and + dynamic. The compressor deals with some chunk of data at a time, and + decides which method to use on a chunk-by-chunk basis. A chunk might + typically be 32K or 64K. If the chunk is uncompressible, then the + "stored" method is used. In this case, the bytes are simply stored as + is, eight bits per byte, with none of the above coding. The bytes are + preceded by a count, since there is no longer an EOB code. + + If the data is compressible, then either the fixed or dynamic methods + are used. In the dynamic method, the compressed data is preceded by + an encoding of the literal/length and distance Huffman codes that are + to be used to decode this block. The representation is itself Huffman + coded, and so is preceded by a description of that code. These code + descriptions take up a little space, and so for small blocks, there is + a predefined set of codes, called the fixed codes. The fixed method is + used if the block codes up smaller that way (usually for quite small + chunks), otherwise the dynamic method is used. In the latter case, the + codes are customized to the probabilities in the current block, and so + can code it much better than the pre-determined fixed codes. + + The Huffman codes themselves are decoded using a multi-level table + lookup, in order to maximize the speed of decoding plus the speed of + building the decoding tables. See the comments below that precede the + lbits and dbits tuning parameters. + */ + +/* + Notes beyond the 1.93a appnote.txt: + + 1. Distance pointers never point before the beginning of the output + stream. + 2. Distance pointers can point back across blocks, up to 32k away. + 3. There is an implied maximum of 7 bits for the bit length table and + 15 bits for the actual data. + 4. If only one code exists, then it is encoded using one bit. (Zero + would be more efficient, but perhaps a little confusing.) If two + codes exist, they are coded using one bit each (0 and 1). + 5. There is no way of sending zero distance codes--a dummy must be + sent if there are none. (History: a pre 2.0 version of PKZIP would + store blocks with no distance codes, but this was discovered to be + too harsh a criterion.) Valid only for 1.93a. 2.04c does allow + zero distance codes, which is sent as one code of zero bits in + length. + 6. There are up to 286 literal/length codes. Code 256 represents the + end-of-block. Note however that the static length tree defines + 288 codes just to fill out the Huffman codes. Codes 286 and 287 + cannot be used though, since there is no length base or extra bits + defined for them. Similarly, there are up to 30 distance codes. + However, static trees define 32 codes (all 5 bits) to fill out the + Huffman codes, but the last two had better not show up in the data. + 7. Unzip can check dynamic Huffman blocks for complete code sets. + The exception is that a single code would not be complete (see #4). + 8. The five bits following the block type is really the number of + literal codes sent minus 257. + 9. Length codes 8,16,16 are interpreted as 13 length codes of 8 bits + (1+6+6). Therefore, to output three times the length, you output + three codes (1+1+1), whereas to output four times the same length, + you only need two codes (1+3). Hmm. + 10. In the tree reconstruction algorithm, Code = Code + Increment + only if BitLength(i) is not zero. (Pretty obvious.) + 11. Correction: 4 Bits: # of Bit Length codes - 4 (4 - 19) + 12. Note: length code 284 can represent 227-258, but length code 285 + really is 258. The last length deserves its own, short code + since it gets used a lot in very redundant files. The length + 258 is special since 258 - 3 (the min match length) is 255. + 13. The literal/length and distance code bit lengths are read as a + single stream of lengths. It is possible (and advantageous) for + a repeat code (16, 17, or 18) to go across the boundary between + the two sets of lengths. + */ + +#include "ultra64/ultratypes.h" +#include "libc/stddef.h" +#include "libc/stdint.h" +#include "alignment.h" +#include "attributes.h" +#include "z64dma.h" + +typedef u8 uch; +typedef u16 ush; +typedef u32 ulg; + +#define Trace(x) +#define Tracev(x) +#define Tracevv(x) +#define Tracecv(c, x) + +#define EOF -1 + +#define WSIZE 0x8000 +#define INBUFSIZ 0x1000 + +typedef struct GzipFileDescriptor { + uintptr_t addr; + s32 size; +} GzipFileDescriptor; + +GzipFileDescriptor ifd; + +unsigned insize; +unsigned inptr; +unsigned outcnt; + +static u8 inbuf[INBUFSIZ]; +static u8* output_ptr; + +int fill_inbuf(int eof_ok); +void flush_window(void); + +/* Huffman code lookup table entry--this entry is four bytes for machines + that have 16-bit pointers (e.g. PC's in the small or medium model). + Valid extra bits are 0..13. e == 15 is EOB (end of block), e == 16 + means that v is a literal, 16 < e < 32 means that v is a pointer to + the next table, which codes e - 16 bits, and lastly e == 99 indicates + an unused code. If a code with e == 99 is looked up, this implies an + error in the data. */ +struct huft { + uch e; /* number of extra bits or operation */ + uch b; /* number of bits in this code or subcode */ + union { + ush n; /* literal, length base, or distance base */ + struct huft* t; /* pointer to next level of table */ + } v; +}; + +/* Function prototypes */ +int huft_free(struct huft*); + +/* The inflate algorithm uses a sliding 32K byte window on the uncompressed + stream to find repeated byte strings. This is implemented here as a + circular buffer. The index is updated simply by incrementing and then + and'ing with 0x7fff (32K-1). */ +/* It is left to other modules to supply the 32K area. It is assumed + to be usable as if it were declared "uch slide[32768];" or as just + "uch *slide;" and then malloc'ed in the latter case. The definition + must be in unzip.h, included above. */ +/* unsigned wp; current position in slide */ +#define wp outcnt +#define flush_output(w) (wp = (w), flush_window()) + +/* Tables for deflate from PKZIP's appnote.txt. */ +static unsigned border[] = { /* Order of the bit length code lengths */ + 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15 +}; +static ush cplens[] = { /* Copy lengths for literal codes 257..285 */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0 +}; +/* note: see note #13 above about the 258 in this list. */ +static ush cplext[] = { /* Extra bits for literal codes 257..285 */ + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 99, 99 +}; /* 99==invalid */ +static ush cpdist[] = { /* Copy offsets for distance codes 0..29 */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, + 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577 +}; +static ush cpdext[] = { /* Extra bits for distance codes */ + 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13 +}; + +/* Macros for inflate() bit peeking and grabbing. + The usage is: + + NEEDBITS(j) + x = b & mask_bits[j]; + DUMPBITS(j) + + where NEEDBITS makes sure that b has at least j bits in it, and + DUMPBITS removes the bits from b. The macros use the variable k + for the number of bits in b. Normally, b and k are register + variables for speed, and are initialized at the beginning of a + routine that uses these macros from a global bit buffer and count. + The macros also use the variable w, which is a cached copy of wp. + + If we assume that EOB will be the longest code, then we will never + ask for bits with NEEDBITS that are beyond the end of the stream. + So, NEEDBITS should not read any more bytes than are needed to + meet the request. Then no bytes need to be "returned" to the buffer + at the end of the last block. + + However, this assumption is not true for fixed blocks--the EOB code + is 7 bits, but the other literal/length codes can be 8 or 9 bits. + (The EOB code is shorter than other codes because fixed blocks are + generally short. So, while a block always has an EOB, many other + literal/length codes have a significantly lower probability of + showing up at all.) However, by making the first table have a + lookup of seven bits, the EOB code will be found in that first + lookup, and so will not require that too many bits be pulled from + the stream. + */ + +ulg bb; /* bit buffer */ +unsigned bk; /* bits in bit buffer */ + +static ush mask_bits[] = { 0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, + 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff }; + +#define GETBYTE() (inptr < insize ? inbuf[inptr++] : fill_inbuf(0)) + +#define NEXTBYTE() (uch) GETBYTE() +#define NEEDBITS(n) \ + { \ + while (k < (n)) { \ + b |= ((ulg)NEXTBYTE()) << k; \ + k += 8; \ + } \ + } +#define DUMPBITS(n) \ + { \ + b >>= (n); \ + k -= (n); \ + } + +/* + Huffman code decoding is performed using a multi-level table lookup. + The fastest way to decode is to simply build a lookup table whose + size is determined by the longest code. However, the time it takes + to build this table can also be a factor if the data being decoded + is not very long. The most common codes are necessarily the + shortest codes, so those codes dominate the decoding time, and hence + the speed. The idea is you can have a shorter table that decodes the + shorter, more probable codes, and then point to subsidiary tables for + the longer codes. The time it costs to decode the longer codes is + then traded against the time it takes to make longer tables. + + This results of this trade are in the variables lbits and dbits + below. lbits is the number of bits the first level table for literal/ + length codes can decode in one step, and dbits is the same thing for + the distance codes. Subsequent tables are also less than or equal to + those sizes. These values may be adjusted either when all of the + codes are shorter than that, in which case the longest code length in + bits is used, or when the shortest code is *longer* than the requested + table size, in which case the length of the shortest code in bits is + used. + + There are two different values for the two tables, since they code a + different number of possibilities each. The literal/length table + codes 286 possible values, or in a flat code, a little over eight + bits. The distance table codes 30 possible values, or a little less + than five bits, flat. The optimum values for speed end up being + about one bit more than those, so lbits is 8+1 and dbits is 5+1. + The optimum values may differ though from machine to machine, and + possibly even between compilers. Your mileage may vary. + */ + +static int lbits = 9; /* bits in base literal/length lookup table */ +static int dbits = 6; /* bits in base distance lookup table */ + +/* If BMAX needs to be larger than 16, then h and x[] should be ulg. */ +#define BMAX 16 /* maximum bit length of any code (16 for explode) */ +#define N_MAX 288 /* maximum number of codes in any set */ + +unsigned hufts; /* track memory usage */ + +#define MEMBUFSIZ 0x2000 + +static u8 gzip_mem_buff[MEMBUFSIZ]; +void* gzip_malloc_addr = gzip_mem_buff; +s32 gzip_malloc_tmp = 0; + +void* gzip_malloc(size_t size) { + void* ret; + + gzip_malloc_tmp += size; + if (gzip_malloc_tmp > MEMBUFSIZ) { + return NULL; + } + + ret = gzip_malloc_addr; + gzip_malloc_addr = (void*)(((uintptr_t)gzip_malloc_addr) + size); + return ret; +} + +void gzip_free(void* ptr) { + gzip_malloc_tmp = 0; + gzip_malloc_addr = gzip_mem_buff; +} + +/* Given a list of code lengths and a maximum table size, make a set of + tables to decode that set of codes. Return zero on success, one if + the given code set is incomplete (the tables are still built in this + case), two if the input is invalid (all zero length codes or an + oversubscribed set of lengths), and three if not enough memory. */ +int huft_build(unsigned* b, /* code lengths in bits (all assumed <= BMAX) */ + unsigned n, /* number of codes (assumed <= N_MAX) */ + unsigned s, /* number of simple-valued codes (0..s-1) */ + ush* d, /* list of base values for non-simple codes */ + ush* e, /* list of extra bits for non-simple codes */ + struct huft** t, /* result: starting table */ + int* m /* maximum lookup bits, returns actual */ +) { + unsigned a; /* counter for codes of length k */ + unsigned c[BMAX + 1]; /* bit length count table */ + unsigned f; /* i repeats in table every f entries */ + int g; /* maximum code length */ + int h; /* table level */ + register unsigned i; /* counter, current code */ + register unsigned j; /* counter */ + register int k; /* number of bits in current code */ + int l; /* bits per table (returned in m) */ + register unsigned* p; /* pointer into c[], b[], or v[] */ + register struct huft* q; /* points to current table */ + struct huft r; /* table entry for structure assignment */ + struct huft* u[BMAX]; /* table stack */ + static unsigned v[N_MAX]; /* values in order of bit length */ + register int w; /* bits before this table == (l * h) */ + unsigned x[BMAX + 1]; /* bit offsets, then code stack */ + unsigned* xp; /* pointer into x */ + int y; /* number of dummy codes added */ + unsigned z; /* number of entries in current table */ + + /* Generate counts for each bit length */ + for (j = 0; j < BMAX + 1; j++) { + c[j] = 0; + } + + p = b; + i = n; + do { + Tracecv(*p, (stderr, (n - i >= ' ' && n - i <= '~' ? "%c %d\n" : "0x%x %d\n"), n - i, *p)); + c[*p]++; /* assume all entries <= BMAX */ + p++; /* Can't combine with above line (Solaris bug) */ + } while (--i); + if (c[0] == n) { /* null input--all zero length codes */ + *t = NULL; + *m = 0; + return 0; + } + + /* Find minimum and maximum length, bound *m by those */ + l = *m; + for (j = 1; j <= BMAX; j++) { + if (c[j]) { + break; + } + } + k = j; /* minimum code length */ + if ((unsigned)l < j) { + l = j; + } + for (i = BMAX; i; i--) { + if (c[i]) { + break; + } + } + g = i; /* maximum code length */ + if ((unsigned)l > i) { + l = i; + } + *m = l; + + /* Adjust last length count to fill out codes, if needed */ + for (y = 1 << j; j < i; j++, y <<= 1) { + if ((y -= c[j]) < 0) { + return 2; /* bad input: more codes than bits */ + } + } + if ((y -= c[i]) < 0) { + return 2; + } + c[i] += y; + + /* Generate starting offsets into the value table for each length */ + x[1] = j = 0; + p = c + 1; + xp = x + 2; + while (--i) { /* note that i == g from above */ + *xp++ = (j += *p++); + } + + /* Make a table of values in order of bit lengths */ + p = b; + i = 0; + do { + if ((j = *p++) != 0) { + v[x[j]++] = i; + } + } while (++i < n); + + /* Generate the Huffman codes and for each, make the table entries */ + x[0] = i = 0; /* first Huffman code is zero */ + p = v; /* grab values in bit order */ + h = -1; /* no tables yet--level -1 */ + w = -l; /* bits decoded == (l * h) */ + u[0] = (struct huft*)NULL; /* just to keep compilers happy */ + q = (struct huft*)NULL; /* ditto */ + z = 0; /* ditto */ + + /* go through the bit lengths (k already is bits in shortest code) */ + for (; k <= g; k++) { + a = c[k]; + while (a--) { + /* here i is the Huffman code of length k bits for value *p */ + /* make tables up to required level */ + while (k > w + l) { + h++; + w += l; /* previous table always l bits */ + + /* compute minimum size table less than or equal to l bits */ + z = (z = g - w) > (unsigned)l ? l : z; /* upper limit on table size */ + if ((f = 1 << (j = k - w)) > a + 1) { /* try a k-w bit table */ + /* too few codes for k-w bit table */ + f -= a + 1; /* deduct codes from patterns left */ + xp = c + k; + while (++j < z) { /* try smaller tables up to z bits */ + if ((f <<= 1) <= *++xp) { + break; /* enough codes to use up j bits */ + } + f -= *xp; /* else deduct codes from patterns */ + } + } + z = 1 << j; /* table entries for j-bit table */ + + /* allocate and link in new table */ + if ((q = (struct huft*)gzip_malloc((z + 1) * sizeof(struct huft))) == (struct huft*)NULL) { + if (h) { + huft_free(u[0]); + } + return 3; /* not enough memory */ + } + hufts += z + 1; /* track memory usage */ + *t = q + 1; /* link to list for huft_free() */ + *(t = &(q->v.t)) = (struct huft*)NULL; + u[h] = ++q; /* table starts after link */ + + /* connect to last table, if there is one */ + if (h) { + x[h] = i; /* save pattern for backing up */ + r.b = (uch)l; /* bits to dump before this table */ + r.e = (uch)(16 + j); /* bits in this table */ + r.v.t = q; /* pointer to this table */ + j = i >> (w - l); /* (get around Turbo C bug) */ + u[h - 1][j] = r; /* connect to last table */ + } + } + + /* set up table entry in r */ + r.b = (uch)(k - w); + if (p >= v + n) { + r.e = 99; /* out of values--invalid code */ + } else if (*p < s) { + r.e = (uch)(*p < 256 ? 16 : 15); /* 256 is end-of-block code */ + r.v.n = (ush)(*p); /* simple code is just the value */ + p++; /* one compiler does not like *p++ */ + } else { + r.e = (uch)e[*p - s]; /* non-simple--look up in lists */ + r.v.n = d[*p++ - s]; + } + + /* fill code-like entries with r */ + f = 1 << (k - w); + for (j = i >> w; j < z; j += f) { + q[j] = r; + } + + /* backwards increment the k-bit code i */ + for (j = 1 << (k - 1); i & j; j >>= 1) { + i ^= j; + } + i ^= j; + + /* backup over finished tables */ + while ((i & ((1 << w) - 1)) != x[h]) { + h--; /* don't need to update q */ + w -= l; + } + } + } + + /* Return true (1) if we were given an incomplete table */ + return y != 0 && g != 1; +} + +/* Free the malloc'ed tables T built by huft_build(), which makes a linked + list of the tables it made, with the links in a dummy first entry of + each table. */ +int huft_free(struct huft* t) { + register struct huft *p, *q; + + /* Go through linked list, freeing from the malloced (t[-1]) address. */ + p = t; + while (p != (struct huft*)NULL) { + q = (--p)->v.t; + gzip_free(p); + p = q; + } + return 0; +} + +/* tl, td: literal/length and distance decoder tables */ +/* bl, bd: number of bits decoded by tl[] and td[] */ +/* inflate (decompress) the codes in a deflated (compressed) block. + Return an error code or zero if it all goes ok. */ +int inflate_codes(struct huft* tl, struct huft* td, int bl, int bd) { + register unsigned e; /* table entry flag/number of extra bits */ + unsigned n, d; /* length and index for copy */ + unsigned w; /* current window position */ + struct huft* t; /* pointer to table entry */ + unsigned ml, md; /* masks for bl and bd bits */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + unsigned char* p; + + /* make local copies of globals */ + b = bb; /* initialize bit buffer */ + k = bk; + w = wp; /* initialize window position */ + + /* inflate the coded data */ + ml = mask_bits[bl]; /* precompute masks for speed */ + md = mask_bits[bd]; + for (;;) { /* do until end of block */ + NEEDBITS((unsigned)bl) + if ((e = (t = tl + ((unsigned)b & ml))->e) > 16) { + do { + if (e == 99) { + return 1; + } + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16); + } + DUMPBITS(t->b) + if (e == 16) { /* then it's a literal */ + *output_ptr++ = (uch)t->v.n; + w++; + if (w == WSIZE) { + flush_output(w); + w = 0; + } + } else { /* it's an EOB or a length */ + /* exit if end of block */ + if (e == 15) { + break; + } + + /* get length of block to copy */ + NEEDBITS(e) + n = t->v.n + ((unsigned)b & mask_bits[e]); + DUMPBITS(e); + + /* decode distance of block to copy */ + NEEDBITS((unsigned)bd) + if ((e = (t = td + ((unsigned)b & md))->e) > 16) { + do { + if (e == 99) { + return 1; + } + DUMPBITS(t->b) + e -= 16; + NEEDBITS(e) + } while ((e = (t = t->v.t + ((unsigned)b & mask_bits[e]))->e) > 16); + } + DUMPBITS(t->b) + NEEDBITS(e) + d = w - t->v.n - ((unsigned)b & mask_bits[e]); + DUMPBITS(e) + Tracevv((stderr, "\\[%d,%d]", w - d, n)); + + /* do the copy */ + p = output_ptr + d - w; + do { + *output_ptr++ = *p++; + w++; + if (w == WSIZE) { + flush_output(w); + w = 0; + } + d++; + n--; + } while (n != 0); + } + } + + /* restore the globals from the locals */ + wp = w; /* restore global window pointer */ + bb = b; /* restore global bit buffer */ + bk = k; + + /* done */ + return 0; +} + +/* "decompress" an inflated type 0 (stored) block. */ +int inflate_stored(void) { + unsigned n; /* number of bytes in block */ + unsigned w; /* current window position */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + /* make local copies of globals */ + b = bb; /* initialize bit buffer */ + k = bk; + w = wp; /* initialize window position */ + + /* go to byte boundary */ + n = k & 7; + DUMPBITS(n); + + /* get the length and its complement */ + NEEDBITS(16) + n = ((unsigned)b & 0xffff); + DUMPBITS(16) + NEEDBITS(16) + if (n != (unsigned)((~b) & 0xffff)) { + return 1; /* error in compressed data */ + } + DUMPBITS(16) + + /* read and output the compressed data */ + while (n--) { + NEEDBITS(8) + *output_ptr++ = (uch)b; + w++; + if (w == WSIZE) { + flush_output(w); + w = 0; + } + DUMPBITS(8) + } + + /* restore the globals from the locals */ + wp = w; /* restore global window pointer */ + bb = b; /* restore global bit buffer */ + bk = k; + return 0; +} + +/* decompress an inflated type 1 (fixed Huffman codes) block. We should + either replace this with a custom decoder, or at least precompute the + Huffman tables. */ +int inflate_fixed(void) { + int i; /* temporary variable */ + struct huft* tl; /* literal/length code table */ + struct huft* td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + static unsigned l[288]; /* length list for huft_build */ + + /* set up literal table */ + for (i = 0; i < 144; i++) { + l[i] = 8; + } + for (; i < 256; i++) { + l[i] = 9; + } + for (; i < 280; i++) { + l[i] = 7; + } + for (; i < 288; i++) { /* make a complete, but wrong code set */ + l[i] = 8; + } + bl = 7; + if ((i = huft_build(l, 288, 257, cplens, cplext, &tl, &bl)) != 0) { + return i; + } + + /* set up distance table */ + for (i = 0; i < 30; i++) { /* make an incomplete code set */ + l[i] = 5; + } + bd = 5; + if ((i = huft_build(l, 30, 0, cpdist, cpdext, &td, &bd)) > 1) { + huft_free(tl); + return i; + } + + /* decompress until an end-of-block code */ + if (inflate_codes(tl, td, bl, bd)) { + return 1; + } + + /* free the decoding tables, return */ + huft_free(td); + huft_free(tl); + return 0; +} + +/* decompress an inflated type 2 (dynamic Huffman codes) block. */ +int inflate_dynamic(void) { + int i; /* temporary variables */ + unsigned j; + unsigned l; /* last length */ + unsigned m; /* mask for bit lengths table */ + unsigned n; /* number of lengths to get */ + UNUSED unsigned w; /* current window position */ + struct huft* tl; /* literal/length code table */ + struct huft* td; /* distance code table */ + int bl; /* lookup bits for tl */ + int bd; /* lookup bits for td */ + unsigned nb; /* number of bit length codes */ + unsigned nl; /* number of literal/length codes */ + unsigned nd; /* number of distance codes */ + static unsigned ll[288 + 32]; /* literal/length and distance code lengths */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + /* make local bit buffer */ + b = bb; + k = bk; + w = wp; + + /* read in table lengths */ + NEEDBITS(5) + nl = 257 + ((unsigned)b & 0x1f); /* number of literal/length codes */ + DUMPBITS(5) + NEEDBITS(5) + nd = 1 + ((unsigned)b & 0x1f); /* number of distance codes */ + DUMPBITS(5) + NEEDBITS(4) + nb = 4 + ((unsigned)b & 0xf); /* number of bit length codes */ + DUMPBITS(4) + if (nl > 288 || nd > 32) { + return 1; /* bad lengths */ + } + + /* read in bit-length-code lengths */ + for (j = 0; j < nb; j++) { + NEEDBITS(3) + ll[border[j]] = (unsigned)b & 7; + DUMPBITS(3) + } + for (; j < 19; j++) { + ll[border[j]] = 0; + } + + /* build decoding table for trees--single level, 7 bit lookup */ + bl = 7; + if ((i = huft_build(ll, 19, 19, NULL, NULL, &tl, &bl)) != 0) { + if (i == 1) { + huft_free(tl); + } + return i; /* incomplete code set */ + } + + /* read in literal and distance code lengths */ + n = nl + nd; + m = mask_bits[bl]; + i = l = 0; + while ((unsigned)i < n) { + NEEDBITS((unsigned)bl) + j = (td = tl + ((unsigned)b & m))->b; + DUMPBITS(j) + j = td->v.n; + if (j < 16) { /* length of code in bits (0..15) */ + ll[i++] = l = j; /* save last length in l */ + } else if (j == 16) { /* repeat last length 3 to 6 times */ + NEEDBITS(2) + j = 3 + ((unsigned)b & 3); + DUMPBITS(2) + if ((unsigned)i + j > n) { + return 1; + } + while (j--) { + ll[i++] = l; + } + } else if (j == 17) { /* 3 to 10 zero length codes */ + NEEDBITS(3) + j = 3 + ((unsigned)b & 7); + DUMPBITS(3) + if ((unsigned)i + j > n) { + return 1; + } + while (j--) { + ll[i++] = 0; + } + l = 0; + } else { /* j == 18: 11 to 138 zero length codes */ + NEEDBITS(7) + j = 11 + ((unsigned)b & 0x7f); + DUMPBITS(7) + if ((unsigned)i + j > n) { + return 1; + } + while (j--) { + ll[i++] = 0; + } + l = 0; + } + } + + /* free decoding table for trees */ + huft_free(tl); + + /* restore the global bit buffer */ + bb = b; + bk = k; + + /* build the decoding tables for literal/length and distance codes */ + bl = lbits; + if ((i = huft_build(ll, nl, 257, cplens, cplext, &tl, &bl)) != 0) { + if (i == 1) { + Trace((stderr, " incomplete literal tree\n")); + huft_free(tl); + } + return i; /* incomplete code set */ + } + bd = dbits; + if ((i = huft_build(ll + nl, nd, 0, cpdist, cpdext, &td, &bd)) != 0) { + if (i == 1) { + Trace((stderr, " incomplete distance tree\n")); + i = 0; + } + } + + /* decompress until an end-of-block code */ + if (inflate_codes(tl, td, bl, bd) != 0) { + return 1; + } + + /* free the decoding tables */ + huft_free(td); + huft_free(tl); + + return 0; +} + +/* decompress an inflated block */ +/* E is the last block flag */ +int inflate_block(int* e) { + unsigned t; /* block type */ + UNUSED unsigned w; /* current window position */ + register ulg b; /* bit buffer */ + register unsigned k; /* number of bits in bit buffer */ + + /* make local bit buffer */ + b = bb; + k = bk; + w = wp; + + /* read in last block bit */ + NEEDBITS(1) + *e = (int)b & 1; + DUMPBITS(1) + + /* read in block type */ + NEEDBITS(2) + t = (unsigned)b & 3; + DUMPBITS(2) + + /* restore the global bit buffer */ + bb = b; + bk = k; + + /* inflate that block type */ + if (t == 2) { + return inflate_dynamic(); + } + if (t == 0) { + return inflate_stored(); + } + if (t == 1) { + return inflate_fixed(); + } + + /* bad block type */ + return 2; +} + +/* decompress an inflated entry */ +int inflate(void) { + int e; /* last block flag */ + int r; /* result code */ + unsigned h; /* maximum struct huft's malloc'ed */ + + /* initialize window, bit buffer */ + wp = 0; + bk = 0; + bb = 0; + + gzip_malloc_tmp = 0; + gzip_malloc_addr = gzip_mem_buff; + + /* decompress until the last block */ + h = 0; + do { + hufts = 0; + if ((r = inflate_block(&e)) != 0) { + return r; + } + if (hufts > h) { + h = hufts; + } + } while (!e); + + /* Undo too much lookahead. The next read will be byte aligned so we + * can discard unused bits in the last meaningful byte. + */ + while (bk >= 8) { + bk -= 8; + inptr--; + } + + /* flush out slide */ + flush_output(wp); + + /* return success */ + Trace((stderr, "<%u> ", h)); + return 0; +} + +size_t gzip_read(GzipFileDescriptor* romInput, void* dst, size_t blockSize) { + size_t alignedSize; + + if (blockSize > (size_t)romInput->size) { + blockSize = romInput->size; + } + + alignedSize = ALIGN8(blockSize); + if (alignedSize > 0) { + DmaMgr_DmaRomToRam(romInput->addr, dst, alignedSize); + } + + romInput->size -= alignedSize; + romInput->addr += alignedSize; + if (romInput->size < 0) { + romInput->size = 0; + } + + return blockSize; +} + +int unzip(void) { + int ret = inflate(); + + if (ret == 3) { + return -1; + } + + if (ret != 0) { + return -1; + } + + return 0; +} + +void clear_bufs(void) { + insize = inptr = 0; +} + +int fill_inbuf(int eof_ok) { + int len; + + /* Read as much as possible */ + insize = 0; + do { + len = gzip_read(&ifd, (char*)inbuf + insize, INBUFSIZ - insize); + if (len == 0 || len == -1) { + break; + } + insize += len; + } while (insize < INBUFSIZ); + + if (insize == 0) { + if (eof_ok) { + return EOF; + } + } + + inptr = 1; + return inbuf[0]; +} + +void flush_window(void) { + outcnt = 0; +} + +void gzip_decompress(uintptr_t romStart, u8* dst, size_t size) { + ifd.addr = romStart; + ifd.size = size; + + output_ptr = dst; + + clear_bufs(); + unzip(); +} diff --git a/src/boot/z_std_dma.c b/src/boot/z_std_dma.c index b05b188c64..ea934a497d 100644 --- a/src/boot/z_std_dma.c +++ b/src/boot/z_std_dma.c @@ -441,7 +441,13 @@ void DmaMgr_ProcessRequest(DmaRequest* req) { // Reduce the thread priority and decompress the file, the decompression routine handles the DMA // in chunks. Restores the thread priority when done. osSetThreadPri(NULL, THREAD_PRI_DMAMGR_LOW); + +#if !PLATFORM_IQUE Yaz0_Decompress(romStart, ram, romSize); +#else + gzip_decompress(romStart, ram, romSize); +#endif + osSetThreadPri(NULL, THREAD_PRI_DMAMGR); found = true; diff --git a/tools/disasm/ique-cn/files_boot.csv b/tools/disasm/ique-cn/files_boot.csv index da3d146a1f..e4d69b501e 100644 --- a/tools/disasm/ique-cn/files_boot.csv +++ b/tools/disasm/ique-cn/files_boot.csv @@ -3,7 +3,7 @@ offset,vram,.text 140,80000590,src/boot/idle 390,800007E0,src/boot/viconfig 4D0,80000920,src/boot/z_std_dma -B50,80000FA0,src/boot/zlib +B50,80000FA0,src/boot/inflate 2830,80002C80,src/boot/z_locale 2870,80002CC0,src/boot/is_debug 2890,80002CE0,src/boot/driverominit @@ -96,7 +96,7 @@ offset,vram,.data 98F0,80009D40,src/boot/viconfig 9910,80009D60,src/boot/carthandle 9920,80009D70,src/boot/z_std_dma -9930,80009D80,src/boot/zlib +9930,80009D80,src/boot/inflate 9AB0,80009F00,src/boot/z_locale 9AC0,80009F10,src/boot/driverominit 9AD0,80009F20,src/libu64/stackcheck @@ -133,7 +133,7 @@ A750,8000ABA0,data/boot_common_8000ABA0 A7A0,8000ABF0,src/boot/boot_main B190,8000B5E0,src/boot/idle BD90,8000C1E0,src/boot/z_std_dma -C500,8000C950,src/boot/zlib +C500,8000C950,src/boot/inflate 10310,80010760,src/boot/driverominit 10390,800107E0,src/libultra/io/vimgr 115B0,80011A00,src/libultra/io/pimgr diff --git a/tools/disasm/ique-cn/functions.txt b/tools/disasm/ique-cn/functions.txt index b10ad38737..41abd66a7c 100644 --- a/tools/disasm/ique-cn/functions.txt +++ b/tools/disasm/ique-cn/functions.txt @@ -15,6 +15,22 @@ DmaMgr_ThreadEntry = 0x80000D60; // type:func DmaMgr_RequestAsync = 0x80000DC4; // type:func DmaMgr_RequestSync = 0x80000E14; // type:func DmaMgr_Init = 0x80000EAC; // type:func +gzip_malloc = 0x80000FA0; // type:func +gzip_free = 0x80000FE8; // type:func +huft_build = 0x80001004; // type:func +huft_free = 0x800015E8; // type:func +inflate_codes = 0x8000162C; // type:func +inflate_stored = 0x80001BCC; // type:func +inflate_fixed = 0x80001E4C; // type:func +inflate_dynamic = 0x80002018; // type:func +inflate_block = 0x80002808; // type:func +inflate = 0x800029B0; // type:func +gzip_read = 0x80002A88; // type:func +unzip = 0x80002B14; // type:func +clear_bufs = 0x80002B50; // type:func +fill_inbuf = 0x80002B68; // type:func +flush_window = 0x80002C2C; // type:func +gzip_decompress = 0x80002C3C; // type:func Locale_Init = 0x80002C80; // type:func Locale_ResetRegion = 0x80002CB4; // type:func osSyncPrintfUnused = 0x80002CC0; // type:func @@ -10285,7 +10301,7 @@ EnGe1_Init = 0x80A8EFD0; // type:func EnGe1_Destroy = 0x80A8F294; // type:func EnGe1_SetTalkAction = 0x80A8F2C0; // type:func EnGe1_SetAnimationIdle = 0x80A8F3A0; // type:func -EnGe1_CheckCarpentersFreed = 0x80A8F424; // type:func +EnGe1_CheckAllCarpentersRescued = 0x80A8F424; // type:func EnGe1_KickPlayer = 0x80A8F460; // type:func EnGe1_SpotPlayer = 0x80A8F540; // type:func EnGe1_WatchForPlayerFrontOnly = 0x80A8F5A0; // type:func @@ -11822,7 +11838,7 @@ EnGe2_Init = 0x80B25578; // type:func EnGe2_Destroy = 0x80B25790; // type:func Ge2_DetectPlayerInAction = 0x80B257BC; // type:func Ge2_DetectPlayerInUpdate = 0x80B25868; // type:func -EnGe2_CheckCarpentersFreed = 0x80B25998; // type:func +EnGe2_CheckAllCarpentersRescued = 0x80B25998; // type:func EnGe2_CaptureClose = 0x80B259C4; // type:func EnGe2_CaptureCharge = 0x80B25A98; // type:func EnGe2_CaptureTurn = 0x80B25BCC; // type:func