X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=bitstream.c;h=dfc1e55e67aced611014fc90b86128e8bd61a457;hp=f0f6012c84a1e4df95b7293f4b1c1459f937e275;hb=f932f45196a8a4480ad910c455abe8aae9824967;hpb=5f440e02ddea20370917c67cc5ea71cedbbfabbc diff --git a/bitstream.c b/bitstream.c index f0f6012c..dfc1e55e 100644 --- a/bitstream.c +++ b/bitstream.c @@ -6,41 +6,39 @@ * Copyright (c) 2000, 2001 Fabrice Bellard * Copyright (c) 2002-2004 Michael Niedermayer * alternative bitstream reader & writer by Michael Niedermayer + * Copyright (C) 2009 Andre Noll * - * Licensed under the GNU Lesser General Public License. - * For licencing details see COPYING.LIB. + * Licensed under the GNU Lesser General Public License. see file COPYING.LIB. */ -/** - * \file bitstream.c Bitstream API. - */ +/** \file bitstream.c Bitstream API for the wma decoder. */ -#include -#include -#include -#include #include #include "para.h" #include "error.h" #include "string.h" #include "wma.h" +#include "portable_io.h" #include "bitstream.h" -#define GET_DATA(v, table, i, size) \ -{\ - const uint8_t *ptr = (const uint8_t *)table + i * size; \ - switch (size) { \ - case 1: \ - v = *(const uint8_t *)ptr; \ - break; \ - case 2: \ - v = *(const uint16_t *)ptr; \ - break; \ - default: \ - v = *(const uint32_t *)ptr; \ - break; \ - } \ +static inline uint32_t get_data(const void *table, int i, int size) +{ + const uint8_t *ptr = (const uint8_t *)table + i * size; + uint32_t v; + + switch (size) { + case 1: + v = *(const uint8_t *)ptr; + break; + case 2: + v = *(const uint16_t *)ptr; + break; + default: + v = *(const uint32_t *)ptr; + break; + } + return v; } static void alloc_table(struct vlc *vlc, int size) @@ -49,7 +47,7 @@ static void alloc_table(struct vlc *vlc, int size) if (vlc->table_size > vlc->table_allocated) { vlc->table_allocated += (1 << vlc->bits); vlc->table = para_realloc(vlc->table, - sizeof(VLC_TYPE) * 2 * vlc->table_allocated); + sizeof(int16_t) * 2 * vlc->table_allocated); } } @@ -57,10 +55,9 @@ static int build_table(struct vlc *vlc, int table_nb_bits, int nb_codes, const void *bits, const void *codes, int codes_size, uint32_t code_prefix, int n_prefix) { - int i, j, k, n, table_size, table_index, nb, n1, idx, code_prefix2, - symbol; + int i, j, k, n, table_size, table_index, nb, n1, idx; uint32_t code; - VLC_TYPE(*table)[2]; + int16_t (*table)[2]; table_size = 1 << table_nb_bits; table_index = vlc->table_size; @@ -68,62 +65,57 @@ static int build_table(struct vlc *vlc, int table_nb_bits, int nb_codes, table = &vlc->table[table_index]; for (i = 0; i < table_size; i++) { - table[i][1] = 0; //bits - table[i][0] = -1; //codes + table[i][1] = 0; /* bits */ + table[i][0] = -1; /* codes */ } - /* map codes and compute auxillary table sizes */ + /* map codes and compute auxiliary table sizes */ for (i = 0; i < nb_codes; i++) { - GET_DATA(n, bits, i, 1); - GET_DATA(code, codes, i, codes_size); + n = get_data(bits, i, 1); /* we accept tables with holes */ + n -= n_prefix; if (n <= 0) continue; - symbol = i; + code = get_data(codes, i, codes_size); /* if code matches the prefix, it is in the table */ - n -= n_prefix; - code_prefix2 = code >> n; - if (n <= 0 || code_prefix2 != code_prefix) + if ((code >> n) != code_prefix) continue; if (n <= table_nb_bits) { /* no need to add another table */ j = (code << (table_nb_bits - n)) & (table_size - 1); nb = 1 << (table_nb_bits - n); for (k = 0; k < nb; k++) { - if (table[j][1] /* bits */ != 0) { - PARA_EMERG_LOG("incorrect code\n"); - exit(EXIT_FAILURE); - } - table[j][1] = n; //bits - table[j][0] = symbol; + assert(table[j][1] == 0); /* incorrect code */ + table[j][1] = n; /* bits */ + table[j][0] = i; j++; } } else { n -= table_nb_bits; j = (code >> n) & ((1 << table_nb_bits) - 1); /* compute table size */ - n1 = -table[j][1]; //bits + n1 = -table[j][1]; /* bits */ if (n > n1) n1 = n; - table[j][1] = -n1; //bits + table[j][1] = -n1; /* bits */ } } - /* fill auxillary tables recursively */ + /* fill auxiliary tables recursively */ for (i = 0; i < table_size; i++) { - n = table[i][1]; //bits + n = table[i][1]; /* bits */ if (n < 0) { n = -n; if (n > table_nb_bits) { n = table_nb_bits; - table[i][1] = -n; //bits + table[i][1] = -n; /* bits */ } idx = build_table(vlc, n, nb_codes, bits, codes, codes_size, (code_prefix << table_nb_bits) | i, n_prefix + table_nb_bits); /* vlc->table might have changed */ table = &vlc->table[table_index]; - table[i][0] = idx; //code + table[i][0] = idx; /* code */ } } return table_index; @@ -133,19 +125,15 @@ static int build_table(struct vlc *vlc, int table_nb_bits, int nb_codes, * Build VLC decoding tables suitable for use with get_vlc(). * * \param vlc The structure to be initialized. - * - * \param nb_bits Set the decoding table size (2^nb_bits) entries. The bigger - * it is, the faster is the decoding. But it should not be too big to save - * memory and L1 cache. '9' is a good compromise. - * - * \param nb_codes Number of vlcs codes. - * + * \param nb_bits Set the decoding table size (2^nb_bits) entries. + * \param nb_codes Number of vlc codes. * \param bits Table which gives the size (in bits) of each vlc code. - * * \param codes Table which gives the bit pattern of of each vlc code. - * * \param codes_size The number of bytes of each entry of the \a codes tables. * + * The bigger \a nb_bits is, the faster is the decoding. But it should not be + * too big to save memory and L1 cache. '9' is a good compromise. + * * The wrap and size parameters allow to use any memory configuration and * types (byte/word/long) to store the bits and codes tables. */ @@ -160,6 +148,14 @@ void init_vlc(struct vlc *vlc, int nb_bits, int nb_codes, const void *bits, build_table(vlc, nb_bits, nb_codes, bits, codes, codes_size, 0, 0); } +/** + * Deallocate all resources of a VLC table. + * + * \param vlc Pointer to an initialized vlc structure. + * + * The table given by \a vlc must have been initialized earlier via \ref + * init_vlc(). + */ void free_vlc(struct vlc *vlc) { freep(&vlc->table); @@ -169,39 +165,31 @@ void free_vlc(struct vlc *vlc) * Parse a vlc code. * * \param gbc The getbit context structure. - * - * \param table The vlc tables to use. - * - * \param bits The number of bits which will be read at once, must be - * identical to nb_bits in init_vlc(). - * - * \param max_depth The number of times bits bits must be read to completely - * read the longest vlc code = (max_vlc_length + bits - 1) / bits. + * \param vlc The vlc tables to use. * * \return The vlc code. */ -int get_vlc(struct getbit_context *gbc, VLC_TYPE(*table)[2], int bits, - int max_depth) +int get_vlc(struct getbit_context *gbc, const struct vlc *vlc) { int n, idx, nb_bits, code; - idx = show_bits(gbc, bits); - code = table[idx][0]; - n = table[idx][1]; - if (max_depth > 1 && n < 0) { - skip_bits(gbc, bits); + idx = show_bits(gbc, vlc->bits); + code = vlc->table[idx][0]; + n = vlc->table[idx][1]; + if (n < 0) { + skip_bits(gbc, vlc->bits); nb_bits = -n; idx = show_bits(gbc, nb_bits) + code; - code = table[idx][0]; - n = table[idx][1]; - if (max_depth > 2 && n < 0) { + code = vlc->table[idx][0]; + n = vlc->table[idx][1]; + if (n < 0) { skip_bits(gbc, nb_bits); nb_bits = -n; idx = show_bits(gbc, nb_bits) + code; - code = table[idx][0]; - n = table[idx][1]; + code = vlc->table[idx][0]; + n = vlc->table[idx][1]; } } skip_bits(gbc, n); - return code; + return code >= 0? code : -E_VLC; }