diff --strip-trailing-cr -u -r rockbox-daily-20060423_org/apps/codecs/libmad/bit.c rockbox-daily-20060423/apps/codecs/libmad/bit.c --- rockbox-daily-20060423_org/apps/codecs/libmad/bit.c 2005-02-15 18:29:42.000000000 +0100 +++ rockbox-daily-20060423/apps/codecs/libmad/bit.c 2006-04-23 18:04:17.015625000 +0200 @@ -87,9 +87,8 @@ */ void mad_bit_init(struct mad_bitptr *bitptr, unsigned char const *byte) { - bitptr->byte = byte; - bitptr->cache = 0; - bitptr->left = CHAR_BIT; + bitptr->ptr = (unsigned long*)((long)byte & ~3); + bitptr->readbit = ((unsigned long)byte & 3) << 3; } /* @@ -99,17 +98,20 @@ unsigned int mad_bit_length(struct mad_bitptr const *begin, struct mad_bitptr const *end) { - return begin->left + - CHAR_BIT * (end->byte - (begin->byte + 1)) + (CHAR_BIT - end->left); + return end->readbit - begin->readbit; } +unsigned char mad_bit_bitsleft(struct mad_bitptr const *bitptr) +{ + return 8 - (bitptr->readbit & 7); +} /* * NAME: bit->nextbyte() * DESCRIPTION: return pointer to next unprocessed byte */ unsigned char const *mad_bit_nextbyte(struct mad_bitptr const *bitptr) { - return bitptr->left == CHAR_BIT ? bitptr->byte : bitptr->byte + 1; + return (unsigned char const*)bitptr->ptr + ((bitptr->readbit + 7) >> 3); } /* @@ -118,60 +120,44 @@ */ void mad_bit_skip(struct mad_bitptr *bitptr, unsigned int len) { - bitptr->byte += len / CHAR_BIT; - bitptr->left -= len % CHAR_BIT; - - if (bitptr->left > CHAR_BIT) { - bitptr->byte++; - bitptr->left += CHAR_BIT; - } - - if (bitptr->left < CHAR_BIT) - bitptr->cache = *bitptr->byte; + bitptr->readbit += len; } /* * NAME: bit->read() * DESCRIPTION: read an arbitrary number of bits and return their UIMSBF value */ +#define swap(x) (x) +unsigned long bmask[] ICONST_ATTR = +{ 0x00000000, 0x00000001, 0x00000003, 0x00000007, 0x0000000f, 0x0000001f, + 0x0000003f, 0x0000007f, 0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff, + 0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff, 0x0000ffff, 0x0001ffff, + 0x0003ffff, 0x0007ffff, 0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff, + 0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff, 0x0fffffff, 0x1fffffff, + 0x3fffffff, 0x7fffffff, 0xffffffff }; +unsigned long mad_bit_read(struct mad_bitptr *bitptr, unsigned int len) ICODE_ATTR; unsigned long mad_bit_read(struct mad_bitptr *bitptr, unsigned int len) { - register unsigned long value; - - if (bitptr->left == CHAR_BIT) - bitptr->cache = *bitptr->byte; - - if (len < bitptr->left) { - value = (bitptr->cache & ((1 << bitptr->left) - 1)) >> - (bitptr->left - len); - bitptr->left -= len; - - return value; - } - - /* remaining bits in current byte */ - - value = bitptr->cache & ((1 << bitptr->left) - 1); - len -= bitptr->left; - - bitptr->byte++; - bitptr->left = CHAR_BIT; - - /* more bytes */ - - while (len >= CHAR_BIT) { - value = (value << CHAR_BIT) | *bitptr->byte++; - len -= CHAR_BIT; - } - - if (len > 0) { - bitptr->cache = *bitptr->byte; + unsigned long *curr = &bitptr->ptr[bitptr->readbit>>5]; - value = (value << len) | (bitptr->cache >> (CHAR_BIT - len)); - bitptr->left -= len; + if(len) + { + if((bitptr->readbit ^ (bitptr->readbit + len - 1)) < 32) + { + bitptr->readbit += len; + + return (swap(curr[0]) >> (-bitptr->readbit & 31)) & bmask[len]; + } + else + { + bitptr->readbit += len; + + return ((swap(curr[0]) << ( bitptr->readbit & 31)) + + (swap(curr[1]) >> (-bitptr->readbit & 31))) & bmask[len]; + } } - return value; + return 0; } # if 0 diff --strip-trailing-cr -u -r rockbox-daily-20060423_org/apps/codecs/libmad/bit.h rockbox-daily-20060423/apps/codecs/libmad/bit.h --- rockbox-daily-20060423_org/apps/codecs/libmad/bit.h 2005-02-15 18:29:42.000000000 +0100 +++ rockbox-daily-20060423/apps/codecs/libmad/bit.h 2006-04-23 18:04:17.015625000 +0200 @@ -23,9 +23,8 @@ # define LIBMAD_BIT_H struct mad_bitptr { - unsigned char const *byte; - unsigned short cache; - unsigned short left; + unsigned long *ptr; + unsigned long readbit; }; void mad_bit_init(struct mad_bitptr *, unsigned char const *); @@ -35,7 +34,7 @@ unsigned int mad_bit_length(struct mad_bitptr const *, struct mad_bitptr const *); -# define mad_bit_bitsleft(bitptr) ((bitptr)->left) +unsigned char mad_bit_bitsleft(struct mad_bitptr const *bitptr); unsigned char const *mad_bit_nextbyte(struct mad_bitptr const *); void mad_bit_skip(struct mad_bitptr *, unsigned int); diff --strip-trailing-cr -u -r rockbox-daily-20060423_org/apps/codecs/libmad/layer3.c rockbox-daily-20060423/apps/codecs/libmad/layer3.c --- rockbox-daily-20060423_org/apps/codecs/libmad/layer3.c 2006-04-12 06:00:32.000000000 +0200 +++ rockbox-daily-20060423/apps/codecs/libmad/layer3.c 2006-04-23 18:04:49.453125000 +0200 @@ -44,6 +44,13 @@ # include "huffman.h" # include "layer3.h" +/* depending on the cpu "leftshift32" may be supported or not */ +# if defined(CPU_COLDFIRE) && !defined(SIMULATOR) +#define MAXLSHIFT 32 +#else +#define MAXLSHIFT 31 +#endif + /* --- Layer III ----------------------------------------------------------- */ enum { @@ -924,16 +931,17 @@ * DESCRIPTION: decode Huffman code words of one channel of one granule */ static -enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xr[576], +enum mad_error III_huffdecode(struct mad_bitptr *ptr, mad_fixed_t xrarr[576], struct channel *channel, unsigned char const *sfbwidth, unsigned int part2_length) { + unsigned int bits; signed int exponents[39], exp; signed int const *expptr; struct mad_bitptr peek; signed int bits_left, cachesz; - register mad_fixed_t *xrptr; + register mad_fixed_t *xr; mad_fixed_t const *sfbound; register unsigned long bitcache; @@ -943,207 +951,213 @@ III_exponents(channel, sfbwidth, exponents); - peek = *ptr; + peek = *ptr; + cachesz = 0; + sfbound = xr = xrarr; mad_bit_skip(ptr, bits_left); - /* align bit reads to byte boundaries */ - cachesz = mad_bit_bitsleft(&peek); - cachesz += ((32 - 1 - 24) + (24 - cachesz)) & ~7; - - bitcache = mad_bit_read(&peek, cachesz); - bits_left -= cachesz; - - xrptr = &xr[0]; - /* big_values */ { - unsigned int region, rcount; + int region; struct hufftable const *entry; - union huffpair const *table; - unsigned int linbits, startbits, big_values; - mad_fixed_t reqcache[16]; - - sfbound = xrptr + *sfbwidth++; - rcount = channel->region0_count + 1; - - entry = &mad_huff_pair_table[channel->table_select[region = 0]]; - table = entry->table; - linbits = entry->linbits; - startbits = entry->startbits; - - if (table == 0) - return MAD_ERROR_BADHUFFTABLE; - - expptr = &exponents[0]; - exp = *expptr++; - - /* clear cache */ - memset(reqcache, 0, sizeof(reqcache)); - - big_values = channel->big_values; - - while (big_values-- && cachesz + bits_left > 0) { - union huffpair const *pair; - unsigned int clumpsz, value; - register mad_fixed_t requantized; - - if (xrptr == sfbound) { - sfbound += *sfbwidth++; - - /* change table if region boundary */ - - if (--rcount == 0) { - if (region == 0) - rcount = channel->region1_count + 1; - else - rcount = 0; /* all remaining */ - - entry = &mad_huff_pair_table[channel->table_select[++region]]; - table = entry->table; - linbits = entry->linbits; - startbits = entry->startbits; - - if (table == 0) - return MAD_ERROR_BADHUFFTABLE; - } + union huffpair const *table; + unsigned int linbits, startbits, rcount; + mad_fixed_t reqcache[16]; + mad_fixed_t const *xr_end, *xr_big_val; + + rcount = 1; + expptr = &exponents[0]; + region = -1; + exp = 0x3210; /* start value */ + bitcache = 0; + linbits = startbits = 0; + table = NULL; + xr_big_val = xr + 2 * channel->big_values; - if (exp != *expptr) { - exp = *expptr; - memset(reqcache, 0, sizeof(reqcache)); - } - - ++expptr; - } - - if (cachesz < 21) { - unsigned int bits; - - bits = ((32 - 1 - 21) + (21 - cachesz)) & ~7; - bitcache = (bitcache << bits) | mad_bit_read(&peek, bits); - cachesz += bits; - bits_left -= bits; - } - - /* hcod (0..19) */ - - clumpsz = startbits; - pair = &table[MASK(bitcache, cachesz, clumpsz)]; - - while (!pair->final) { - cachesz -= clumpsz; - - clumpsz = pair->ptr.bits; - pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)]; - } - - cachesz -= pair->value.hlen; - - if (linbits) { - /* x (0..14) */ - - value = pair->value.x; - - switch (value) { - case 0: - xrptr[0] = 0; - break; - - case 15: - if ((unsigned int)cachesz < linbits + 2) { - bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); - cachesz += 16; - bits_left -= 16; - } - - value += MASK(bitcache, cachesz, linbits); - cachesz -= linbits; - - requantized = III_requantize(value, exp); - goto x_final; - - default: - if (reqcache[value]) - requantized = reqcache[value]; - else - requantized = reqcache[value] = III_requantize(value, exp); - - x_final: - xrptr[0] = MASK1BIT(bitcache, cachesz--) ? - -requantized : requantized; - } - - /* y (0..14) */ - - value = pair->value.y; - - switch (value) { - case 0: - xrptr[1] = 0; - break; - - case 15: - if ((unsigned int)cachesz < linbits + 1) { - bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); - cachesz += 16; - bits_left -= 16; - } - - value += MASK(bitcache, cachesz, linbits); - cachesz -= linbits; - - requantized = III_requantize(value, exp); - goto y_final; + while(xr < xr_big_val) + { + sfbound += *sfbwidth++; + xr_end = sfbound > xr_big_val ? xr_big_val : sfbound; - default: - if (reqcache[value]) - requantized = reqcache[value]; + /* change table if region boundary */ + if(--rcount == 0) + { + if(exp == 0x3210) + rcount = channel->region0_count + 1; + else + if(region == 0) + rcount = channel->region1_count + 1; else - requantized = reqcache[value] = III_requantize(value, exp); + rcount = 0; /* all remaining */ - y_final: - xrptr[1] = MASK1BIT(bitcache, cachesz--) ? - -requantized : requantized; - } + entry = &mad_huff_pair_table[channel->table_select[++region]]; + table = entry->table; + linbits = entry->linbits; + startbits = entry->startbits; + + if(table == 0) + return MAD_ERROR_BADHUFFTABLE; + } + + if(exp != *expptr) + { + exp = *expptr; + /* clear cache */ + memset(reqcache, 0, sizeof(reqcache)); + } + + ++expptr; + + if(linbits) + { + for( ; xrfinal) + { + cachesz -= clumpsz; + clumpsz = pair->ptr.bits; + pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)]; + } + + cachesz -= pair->value.hlen; + + /* x (0..14) */ + value = pair->value.x; + if(value == 0) + xr[0] = 0; + else + { + if(value == 15) + { + requantized = III_requantize(15+MASK(bitcache, cachesz, linbits), exp); + cachesz -= linbits; + } + else + { + if(reqcache[value]) + requantized = reqcache[value]; + else + requantized = reqcache[value] = III_requantize(value, exp); + } + + if(cachesz < 13) + { + if(cachesz < 0) + return MAD_ERROR_BADHUFFDATA; /* cache underrun */ + + bits = MAXLSHIFT - cachesz; + bitcache = (bitcache << bits) | mad_bit_read(&peek, bits); + cachesz += bits; + } + + xr[0] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized; + } + + /* y (0..14) */ + value = pair->value.y; + if(value == 0) + xr[1] = 0; + else + { + if(value == 15) + { + requantized = III_requantize(15+MASK(bitcache, cachesz, linbits), exp); + cachesz -= linbits; + } + else + { + if(reqcache[value]) + requantized = reqcache[value]; + else + requantized = reqcache[value] = III_requantize(value, exp); + } + xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized; + } + } } - else { - /* x (0..1) */ - - value = pair->value.x; - - if (value == 0) - xrptr[0] = 0; - else { - if (reqcache[value]) - requantized = reqcache[value]; + else + { + for( ; xrfinal) { + cachesz -= clumpsz; + clumpsz = pair->ptr.bits; + pair = &table[pair->ptr.offset + MASK(bitcache, cachesz, clumpsz)]; + } + + cachesz -= pair->value.hlen; + + /* x (0..1) */ + value = pair->value.x; + if(value == 0) + xr[0] = 0; else - requantized = reqcache[value] = III_requantize(value, exp); - - xrptr[0] = MASK1BIT(bitcache, cachesz--) ? - -requantized : requantized; - } - - /* y (0..1) */ + { + if(reqcache[value]) + requantized = reqcache[value]; + else + requantized = reqcache[value] = III_requantize(value, exp); - value = pair->value.y; + xr[0] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized; + } - if (value == 0) - xrptr[1] = 0; - else { - if (reqcache[value]) - requantized = reqcache[value]; + /* y (0..1) */ + value = pair->value.y; + if(value == 0) + xr[1] = 0; else - requantized = reqcache[value] = III_requantize(value, exp); + { + if(reqcache[value]) + requantized = reqcache[value]; + else + requantized = reqcache[value] = III_requantize(value, exp); - xrptr[1] = MASK1BIT(bitcache, cachesz--) ? - -requantized : requantized; - } + xr[1] = MASK1BIT(bitcache, cachesz--) ? -requantized : requantized; + } + } } - - xrptr += 2; } } - if (cachesz + bits_left < 0) + bits_left = ptr->readbit - peek.readbit; + + if(bits_left + cachesz < 0) return MAD_ERROR_BADHUFFDATA; /* big_values overrun */ /* count1 */ @@ -1155,15 +1169,20 @@ requantized = III_requantize(1, exp); - while (cachesz + bits_left > 0 && xrptr <= &xr[572]) { + while(xr <= &xrarr[572] && bits_left + cachesz > 0) + { union huffquad const *quad; /* hcod (1..6) */ + if(cachesz < 10) + { + if(cachesz < 0) + return MAD_ERROR_BADHUFFDATA; /* cache underrun */ - if (cachesz < 10) { - bitcache = (bitcache << 16) | mad_bit_read(&peek, 16); - cachesz += 16; - bits_left -= 16; + bits = MAXLSHIFT - cachesz; + bitcache = (bitcache << bits) | mad_bit_read(&peek, bits); + cachesz += bits; + bits_left -= bits; } quad = &table[MASK(bitcache, cachesz, 4)]; @@ -1178,7 +1197,7 @@ cachesz -= quad->value.hlen; - if (xrptr == sfbound) { + if (xr == sfbound) { sfbound += *sfbwidth++; if (exp != *expptr) { @@ -1190,18 +1209,16 @@ } /* v (0..1) */ - - xrptr[0] = quad->value.v ? + xr[0] = quad->value.v ? (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; /* w (0..1) */ - - xrptr[1] = quad->value.w ? + xr[1] = quad->value.w ? (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; - xrptr += 2; + xr += 2; - if (xrptr == sfbound) { + if (xr == sfbound) { sfbound += *sfbwidth++; if (exp != *expptr) { @@ -1213,42 +1230,26 @@ } /* x (0..1) */ - - xrptr[0] = quad->value.x ? + xr[0] = quad->value.x ? (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; /* y (0..1) */ - - xrptr[1] = quad->value.y ? + xr[1] = quad->value.y ? (MASK1BIT(bitcache, cachesz--) ? -requantized : requantized) : 0; - xrptr += 2; + xr += 2; } - if (cachesz + bits_left < 0) { -# if 0 && defined(DEBUG) - fprintf(stderr, "huffman count1 overrun (%d bits)\n", - -(cachesz + bits_left)); -# endif - + if(bits_left + cachesz < 0) + { /* technically the bitstream is misformatted, but apparently some encoders are just a bit sloppy with stuffing bits */ - - xrptr -= 4; + xr -= 4; } } - assert(-bits_left <= MAD_BUFFER_GUARD * CHAR_BIT); - -# if 0 && defined(DEBUG) - if (bits_left < 0) - fprintf(stderr, "read %d bits too many\n", -bits_left); - else if (cachesz + bits_left > 0) - fprintf(stderr, "%d stuffing bits\n", cachesz + bits_left); -# endif - /* rzero */ - memset(xrptr, 0, (char*)&xr[576] - (char*)xrptr); + memset(xr, 0, (char*)&xrarr[576] - (char*)xr); return MAD_ERROR_NONE; } Only in rockbox-daily-20060423: build Only in rockbox-daily-20060423/tools: bmp2rb.exe Only in rockbox-daily-20060423/tools: codepages.exe Only in rockbox-daily-20060423/tools: convbdf.exe Only in rockbox-daily-20060423/tools: descramble.exe Only in rockbox-daily-20060423/tools: descramble.o Only in rockbox-daily-20060423/tools: iriver.o Only in rockbox-daily-20060423/tools: mkboot.exe Only in rockbox-daily-20060423/tools: rdf2binary.exe Only in rockbox-daily-20060423/tools: scramble.exe Only in rockbox-daily-20060423/tools: scramble.o